Helicopter fault knowledge graph self-learning construction and optimization method and related device

Abstract

This invention discloses a self-learning construction and optimization method and related apparatus for helicopter fault knowledge graphs, belonging to the field of fault diagnosis technology. The method includes: acquiring and preprocessing multi-source fault data to obtain standardized data; identifying entities and relationships from the standardized data to construct an initial candidate graph; calculating the fault association complexity of candidate entity pairs, dynamically allocating graph attention weights, and forming an optimized graph after updating and scoring via a graph neural network; performing missing knowledge mining and erroneous association correction on the optimized graph through a self-learning completion mechanism; and iteratively updating in real time through an active dynamic update mechanism to output the optimized graph. This invention enables the graph propagation strength to dynamically adjust with the fault association complexity, improving the accuracy and extraction efficiency of complex fault causal relationship identification. It possesses dynamic adaptation and self-learning capabilities, achieving automated construction and continuous evolution of the knowledge graph without manual intervention, ensuring the completeness and accuracy of the fault knowledge system.

Description

[0001] This application claims priority to Chinese Patent Application No. 202610704428.7, filed on May 21, 2026, entitled "Method and Apparatus for Self-Learning Construction and Optimization of Helicopter Fault Knowledge Graph". Technical Field

[0002] This invention relates to the field of helicopter fault diagnosis technology, and in particular to a self-learning construction and optimization method and related apparatus for helicopter fault knowledge graph. Background Technology

[0003] The failure mechanisms of critical components in helicopter systems, such as engines, gear reducers, and drive shafts, are characterized by their diverse and complex interrelationships. Current technologies for constructing failure mechanism knowledge graphs typically involve first extracting entities and relationships from multi-source heterogeneous data, such as experimental data, maintenance records, and academic literature, using machine learning or rule templates; secondly, performing cross-source knowledge fusion based on semantic similarity calculations or ontology mapping methods to form an initial knowledge graph; and finally, completing and maintaining the graph through manual review or static rules.

[0004] Existing solutions have the following problems when processing multi-source heterogeneous fault data: (1) Low knowledge extraction efficiency and difficulty in integrating cross-data source and domain knowledge. When dealing with multi-source heterogeneous fault data, the existing solutions mostly use static preset data cleaning rules and knowledge extraction models, which are difficult to adapt to the significant differences in representation granularity and record format of different data sources. At the same time, for the complex relationships such as multi-hop causality and cross-component coupling in the fault mechanism, the existing static models cannot dynamically adjust the extraction strategy, resulting in low knowledge extraction efficiency. Furthermore, semantic conflicts are easily generated when integrating cross-source and cross-domain knowledge, resulting in insufficient integration accuracy.

[0005] (2) The constructed fault knowledge graph is prone to incomplete information. The initially constructed fault knowledge graph generally suffers from missing relationships, missing mechanism chains, and insufficient edge fault knowledge. Existing technologies mainly rely on manual review or rules based on fixed logic to complete the graph. They cannot actively mine the hidden fault mechanism chains from existing knowledge and lack the self-learning ability to continuously optimize with the accumulation of fault knowledge, which makes it difficult to guarantee the completeness and accuracy of the knowledge graph.

[0006] (3) The lack of dynamic updating and maintenance mechanisms makes it impossible to capture the latest results of the fault knowledge system for key helicopter components in real time. The updating of the constructed fault knowledge graph usually relies on manual periodic summarization or passive import, which makes it impossible to capture the latest results of the fault knowledge system for key helicopter components in real time and makes it difficult to meet the actual needs of fault diagnosis of key components of helicopter systems. Summary of the Invention

[0007] The purpose of this invention is to overcome the problems of the prior art and provide a self-learning construction and optimization method and related apparatus for helicopter fault knowledge graph.

[0008] The objective of this invention is achieved through the following technical solution: a self-learning construction and optimization method for helicopter fault knowledge graphs, comprising the following steps: Acquire multi-source fault data related to the target critical components and preprocess it, converting the multi-source fault data into standardized data in a unified format; Entities are identified from standardized data, and candidate triples are generated based on syntactic dependencies, trigger word patterns, temporal sequence relationships, and source co-occurrence relationships. Using identified entities as nodes and candidate triples as edges, an initial fault relationship candidate graph is constructed. The head and tail entities in each candidate triple constitute candidate entity pairs. The fault association complexity between candidate entity pairs in the initial fault relationship candidate graph is calculated. Graph attention weights are dynamically allocated based on the fault association complexity, and message passing updates are performed using a graph neural network based on these weights. Candidate triples are scored, and candidate triples whose scores meet the threshold are written into the initial knowledge graph, forming a fault knowledge graph to be optimized. The fault knowledge graph to be optimized is improved by a self-learning completion mechanism to mine missing knowledge and correct erroneous associations. The corrected fault knowledge graph is iteratively updated in real time through an active dynamic update mechanism, and an optimized fault knowledge graph is output.

[0009] In one embodiment, preprocessing of multi-source fault data includes: For time-series data in multi-source fault data, a sliding window segmentation is adopted, and the statistical features within each window are calculated to form a quality assessment vector. The statistical features include at least one of the following: mean, standard deviation, peak-to-peak value, kurtosis, skewness, and missing rate. For abnormal sample data in multi-source fault data, a combined screening method of statistical discrimination and operating condition constraints is adopted. When the sample data simultaneously meets the statistical anomaly conditions and the physical operating constraint violation conditions, it is judged as abnormal noise data. Preferably, the statistical anomaly conditions are judged by the anomaly discrimination threshold, and the anomaly discrimination threshold is automatically adjusted according to the noise level of the current batch of data. For text data in multi-source fault data, terminology normalization, unit conversion, time alignment, entity normalization, and template completion are performed to convert the original text data into an intermediate standard format.

[0010] In one embodiment, the method further includes cross-source semantic alignment of candidate triples: Construct a fault feature anchor point library, where anchor points include component location, feature mode, operating conditions, and typical faults; Calculate the matching score between candidate entities or candidate relations and anchor templates, where candidate relations are the relation types in candidate triples; Using a domain-adaptive semantic mapping model, the general semantic space is mapped to the helicopter fault domain semantic space to obtain domain semantic vectors. Based on the domain semantic vectors, the domain semantic similarity between candidate triples and predefined standard entities or standard relations in the anchor point library is calculated. The matching score and domain semantic similarity are combined, and the standard entity or standard relationship with the highest score that exceeds the threshold is used as the normalization result.

[0011] In one embodiment, after forming the fault knowledge graph to be optimized, the method further includes: Construct a formal knowledge graph of failure mechanisms, including an entity layer, a relation layer, and an evidence layer; Establish a degradation chain, which includes at least two stages: normal, slight wear, moderate wear, localized peeling, functional degradation, and failure. Based on the operating conditions and the stage transition scoring function, the degradation stage transition probability is defined, and the degradation chain and transition probability are updated to the fault knowledge graph to be optimized.

[0012] In one embodiment, the self-learning completion mechanism includes: The graph completion task is modeled as a sequence decision problem based on reinforcement learning; The environment state is defined as the entity node at the current inference time, the path already traversed, and the local graph context. The action is defined as selecting the next relation and the next hop entity from the current node. The policy network is defined based on the environment state and the action. The probability distribution of each action is output by the policy network. A value function is defined based on the reward obtained after the state transition. The advantage function is estimated based on the value function. The policy network parameters are updated through policy gradient based on the advantage function and the probability distribution output by the policy network. The missing knowledge is mined from the fault knowledge graph to be optimized using the policy network with updated parameters.

[0013] In one embodiment, the self-learning completion mechanism further includes: The graph completeness improvement rate can be determined by the ratio of the number of newly added correct entities or relations to the total number of entities or relations in the graph before completion, or by weighting the connectivity of key entities and the closure of degenerate chains to obtain the graph completeness improvement rate. The association accuracy bonus is calculated based on the ratio of the number of newly verified relationships to the total number of newly added relationships. The total reward is obtained by weighting the completeness improvement rate, the association accuracy rate, and the incorrect association penalty. Based on the total reward, the strategy network, rule candidate pool, and statistical prior model are updated synchronously to complete the missing knowledge mining and error association correction of the fault knowledge graph to be optimized.

[0014] In one embodiment, the proactive dynamic update mechanism includes: Retrieval tasks are generated based on areas of weak knowledge, hot components, and recent abnormal cases, forming a query set; Retrieve a set of candidate documents from external data sources and reorder them based on relevance, source authority, and recentity. The top-ranked documents are used as the generation context, input into the knowledge generation model to generate candidate knowledge entries, and then written into the fault knowledge graph.

[0015] In one embodiment, before writing candidate knowledge entries to the fault knowledge graph, the method further includes: The candidate entries are compared with the core mechanism chain, key parameter range, and component hierarchy of the existing graph, and a consistency score is calculated. The authenticity score is calculated based on whether there is a case number, source organization, original measurement point, maintenance record, or cross-verification from multiple sources. The sufficiency score of evidence is calculated based on the quantity, diversity of types, continuity of time, and reliability of sources. When the weighted sum of the consistency score, authenticity score, and evidence sufficiency score exceeds a preset threshold, the candidate knowledge item is written into the knowledge graph.

[0016] It should be further noted that the technical features corresponding to the above examples can be combined or replaced to form new technical solutions.

[0017] The present invention also includes a computer program product comprising a computer program that, when executed by a processor, implements the steps of the self-learning construction and optimization method for a helicopter fault knowledge graph formed by any or a combination of the above examples.

[0018] The present invention also includes a storage medium storing computer instructions that, when executed, perform the steps of the self-learning construction and optimization method for a helicopter fault knowledge graph formed by any or more of the above examples.

[0019] The present invention also includes a terminal comprising a memory and a processor, wherein the memory stores computer instructions executable on the processor, and the processor executes the steps of the self-learning construction and optimization method for the helicopter fault knowledge graph formed by any or more of the above examples when executing the computer instructions.

[0020] Compared with the prior art, the beneficial effects of the present invention are: 1. By calculating the fault association complexity between candidate entity pairs and dynamically allocating graph attention weights based on the complexity, the graph propagation strength can be dynamically adjusted according to the fault association complexity, making the model's expressive power adapt to the difficulty of the relationship. This enhances the representation capability for complex fault links such as multi-hop causality and cross-component coupling, while avoiding overly smooth relationships and misconnections caused by simple fixed neighborhood propagation. This effectively improves the identification accuracy and extraction efficiency of complex fault causal relationships in key helicopter components, possessing dynamic adaptability and significantly improving the accuracy of complex fault causal relationship identification. Through a self-learning completion mechanism, it can proactively mine hidden fault mechanism chains and autonomously correct erroneous associations without relying on manual intervention, possessing self-learning capabilities and ensuring information completeness and accuracy. Through an active dynamic update mechanism, it can capture the latest fault knowledge in real time and iteratively update the graph. Simultaneously, by combining data preprocessing, self-learning completion, and active update mechanisms, it can achieve automated construction and continuous evolution from multi-source heterogeneous data to an optimized knowledge graph. It can proactively mine missing knowledge and iteratively update the graph in real time without manual intervention, ensuring the completeness, accuracy, and timeliness of the fault knowledge system.

[0021] 2. By using a two-layer fusion mechanism of fault feature anchor matching and domain adaptive semantic mapping, it is possible to achieve semantic alignment of cross-source and cross-domain knowledge while preserving the interpretability of fault physical constraints. This effectively reduces duplicate nodes caused by synonyms and relationship pollution caused by erroneous merging, and improves the consistency and accuracy of multi-source fault knowledge fusion.

[0022] 3. By constructing a formal fault mechanism knowledge graph containing entity, relation, and evidence layers, and establishing performance degradation chains and stage transition probabilities, static fault relationships and dynamic degradation evolution laws can be organically integrated. This enables the knowledge graph to not only support static retrieval of fault mechanisms, but also to describe the complete degradation process of key components from normal to failure, providing structured knowledge support for fault prediction and management.

[0023] 4. By transforming the graph completion task into a reinforcement learning sequence decision problem and utilizing policy networks to autonomously explore high-value reasoning paths, the completion process can be transformed from relying on manual rules and manual edge completion to the system autonomously mining hidden fault mechanism chains, effectively improving the ability to discover complex fault relationships and multi-hop causal chains.

[0024] 5. By constructing a dual reward function consisting of the graph completeness improvement rate and the association accuracy rate, and simultaneously updating the policy network, rule candidate pool, and statistical prior model, the completion task is transformed into a constrained multi-objective optimization problem. This avoids policy bias caused by a single reward objective, which would introduce a large amount of erroneous knowledge. It can achieve synergistic optimization between the quantity and quality control of the expanded graph, ensuring that the system is always constrained by the existing reliable knowledge boundary when exploring unknown relationships, thereby improving the robustness of the completion results.

[0025] 6. By proactively generating retrieval tasks around weak knowledge areas, hot components, and recent abnormal cases, and by using retrieval enhancement generation technology to capture the latest fault knowledge from external data sources in real time, the map can continuously absorb new external knowledge, no longer relying on manual periodic summarization and batch updates, thus improving the timeliness and evolution capability of the map.

[0026] 7. By performing triple credibility verification—consistency check, authenticity verification, and evidence sufficiency assessment—before candidate knowledge is added to the database, the introduction of pseudo-knowledge, conflicting knowledge, and low-quality information during dynamic updates is effectively avoided, ensuring the accuracy, stability, and engineering usability of the knowledge graph after long-term iteration. Attached Figure Description

[0027] The specific embodiments of the present invention will be further described in detail below with reference to the accompanying drawings. The accompanying drawings are provided to provide a further understanding of the present application and constitute a part of the present application. The same reference numerals are used in these drawings to denote the same or similar parts. The illustrative embodiments of the present application and their descriptions are used to explain the present application and do not constitute an improper limitation of the present application.

[0028] Figure 1 This is a flowchart of a method provided in an embodiment of the present invention. Detailed Implementation

[0029] The technical solution of the present invention will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are only some embodiments of the present invention, and not all embodiments. Based on the embodiments of the present invention, all other embodiments obtained by those skilled in the art without creative effort are within the scope of protection of the present invention.

[0030] Furthermore, the technical features involved in the different embodiments of the present invention described below can be combined with each other as long as they do not conflict with each other.

[0031] In one embodiment, such as Figure 1 As shown, a self-learning construction and optimization method for helicopter fault knowledge graphs is proposed, which includes the following steps: S1: Acquire multi-source fault data related to the target critical components and preprocess it, converting the multi-source fault data into standardized data in a unified format.

[0032] In step S1, the multi-source fault data includes at least two of the following: time-series data, text data, semi-structured data, and structured data. Time-series data includes vibration, temperature, pressure, speed, and current data collected by test benches or airborne sensors; text data includes text information from maintenance work cards, troubleshooting records, health assessment reports, and fault case libraries; semi-structured data includes data from academic literature, standard manuals, maintenance procedures, and log forms; and structured data includes data extracted from image recognition results, inspection reports, and tabular files. This embodiment acquires various types of fault-related raw multi-source fault data by constructing a multi-source data acquisition interface. Preprocessing the multi-source fault data involves denoising, field alignment, dimensional unification, and preliminary semantic standardization, providing a unified input for subsequent knowledge extraction. This allows for the acquisition of diverse and complex data features adapted to the fault mechanisms of key helicopter components, enabling adaptive noise removal from various types of fault data (experiments, maintenance, and literature).

[0033] S2: Identify entities from standardized data and generate candidate triples (head entity, relation type, tail entity) based on syntactic dependencies, trigger word patterns, temporal sequence relationships, and source co-occurrence relationships. Using the identified entities as nodes and the candidate triples as edges, construct an initial fault relation candidate graph. The head and tail entities in the candidate triples constitute candidate entity pairs. Calculate the fault association complexity between candidate entity pairs in the initial fault relation candidate graph. Dynamically allocate graph attention weights based on the fault association complexity. Perform message passing updates of the graph neural network based on the graph attention weights. Score the candidate triples and write the candidate triples whose scores meet the score threshold into the initial knowledge graph to form the fault knowledge graph to be optimized.

[0034] In step S2, the entity types include component entities, failure mode entities, failure symptom entities, operating condition entities, damage form entities, maintenance action entities, time entities, and evidence source entities. Component entities include engines, reducers, drive shafts, gears, bearings, etc.; failure mode entities include wear, fracture, fatigue, corrosion, deformation, etc.; failure symptom entities include excessive vibration, abnormal temperature, pressure drop, increased noise, etc.; operating condition entities include takeoff, cruise, hovering, landing, etc.; damage form entities include pitting, peeling, cracking, ablation, etc.; maintenance action entities include replacement, repair, adjustment, etc.; time entities include failure occurrence time, maintenance time, etc.; evidence source entities include literature sources, maintenance record numbers, sensor measurement points, etc. After preprocessing, this step extracts entities and relationships from the standardized data to construct an initial candidate graph of fault relationships. Based on the graph neural network, the algorithm dynamically adjusts the relationships and knowledge extraction, and dynamically adapts the network weights by adjusting the complexity of fault associations. This accurately identifies multi-level causal relationships such as components and faults, faults and mechanisms, and mechanisms and damage, significantly improving the accuracy of knowledge fusion, greatly reducing manual costs, and improving the efficiency and basic quality of graph construction.

[0035] S3: Through a self-learning completion mechanism, missing knowledge is mined and error associations are corrected in the fault knowledge graph to be optimized.

[0036] In step S3, a self-learning inference engine based on reinforcement learning loads the fault knowledge graph to be optimized and the reinforcement learning optimization model, transforms the graph completion task into a sequence decision problem, iteratively optimizes the inference rules and model, realizes missing knowledge mining and error association correction, and outputs an optimized fault mechanism knowledge graph with high completeness and high precision.

[0037] S4: The corrected fault knowledge graph is iteratively updated in real time through an active dynamic update mechanism, and the optimized fault knowledge graph is output.

[0038] In step S4, a real-time fault knowledge monitoring engine is built based on retrieval enhancement generation technology to capture the latest knowledge information. Valid information is filtered through a credibility verification mechanism that verifies knowledge consistency and case authenticity. The engine automatically generates standardized knowledge entries to update the graph, realizing proactive dynamic iteration of the graph.

[0039] Furthermore, based on the optimized fault knowledge graph, when the engine, reducer, or drive shaft exhibits abnormal behavior such as excessive vibration or abnormal temperature, the feature parameters in the real-time monitoring data can be matched with the fault phenomenon nodes in the fault knowledge graph. The multi-hop causal chain in the fault knowledge graph can be used to quickly locate the root cause of the fault and the current stage of the damage evolution.

[0040] In one embodiment, preprocessing of multi-source fault data includes: For numerical time series data, a sliding window segmentation method is used, where the segmentation is defined as follows: Sample sequences within a window for: ; in, Represent data labels. Calculate statistical features within each window to form a quality assessment vector. : ; in, The mean, Standard deviation Peak-to-peak value For ravine, For skewness, This refers to the missing rate or outlier rate.

[0041] For outlier samples, a combined statistical discrimination and operating condition constraint screening method is used for preprocessing. If the sample data... Simultaneously satisfy: ; And the physical operating constraints of the corresponding component under this operating condition are not met. If the data is abnormal noise, then it is considered abnormal noise data. Indicates the current operating condition label. This is the anomaly detection threshold. Preferably, the anomaly detection threshold for data cleaning is automatically adjusted based on the noise level of the current batch of data, and the adaptive threshold update formula is defined as: ; in, For the first Batch anomaly detection threshold; For the first Batch anomaly detection threshold; For the first The ratio of the number of abnormal noise samples obtained after preliminary screening in a batch to the total number of samples in that batch; The target noise rate; To update the step size; This is the preset lower threshold. When When this occurs, it indicates that the current batch noise rate is higher than the target noise rate, and the anomaly detection threshold is lowered. To improve the detection sensitivity of abnormal noise; when At the same time, increase the anomaly detection threshold. This reduces the chance of normal samples being misclassified as abnormal noise; when the two are equal, the current anomaly detection threshold remains unchanged.

[0042] For text data, terminology normalization, unit conversion, time alignment, entity normalization, and template completion are performed sequentially to convert the original text into "components". —Working Conditions —Symptoms of a malfunction — Failure Mode —timestamp —Source Identifier intermediate standard format , denoted as: .

[0043] This embodiment uses an adaptive intelligent cleaning model guided by fault characteristics to remove noise, and then uses data format adjustment and conversion technology to unify the format of multi-source heterogeneous data, realizing fully automated and standardized processing of multi-source heterogeneous fault data. The output standardized dataset serves as the basis for subsequent knowledge extraction.

[0044] In one embodiment, step S2 extracts entities and relationships from the standardized data to construct an initial candidate graph of fault relationships, including: Entities are created jointly using rule templates and domain language models. Recognition. Specifically, candidate text fragments are first located from standardized data based on a preset domain rule template. The domain rule template includes a dictionary or sentence pattern for identifying component names, fault phenomena or fault modes, operating conditions, maintenance measures, and time information. Then, candidate text fragments are... Input a pre-trained domain language model, such as a BERT-based language model, to obtain the probability of each entity belonging to its respective type. It should be noted that the domain language model is fine-tuned using labeled training data from the helicopter malfunction domain. The goal is to minimize the cross-entropy loss function for entity type classification. The Adam optimizer is used for parameter updates, and training continues until the loss function converges or a preset number of training epochs are reached. This enables the model to possess semantic understanding and entity classification capabilities specific to the helicopter malfunction domain. Let the extracted entity set be... for: ; in, This is the entity index. For any text fragment u, the probability that it belongs to entity type y. for: ; in, Represents the probability distribution function; For text encoding vectors, For weight parameters, This is the bias parameter.

[0045] The entity type with the highest probability is selected as the candidate text fragment. The identification type; when the maximum probability is not lower than the preset identification threshold, and the candidate text fragment matches the domain rule template corresponding to the identification type, the candidate text fragment is identified as an entity. and add to the entity collection .

[0046] Then, based on syntactic dependencies, trigger word patterns, temporal sequence relationships, and source co-occurrence relationships, a set of candidate edges for relations is generated. : ; in, For the first One entity; For the first One entity; The relationship type includes at least one of the following: inducing, representing, acting on, causing, accompanying, aggravating, repaired, occurring in, etc.

[0047] To generate candidate heterogeneous graphs for subsequent graph neural network processing, an initial candidate graph of fault relationships is established. : ; in, It is a set of entity attributes, including the time of occurrence, operating condition range, number of pieces of evidence, and credibility of the source.

[0048] In one embodiment, to address the issues of multi-hop causality, cross-component coupling, and high ambiguity in fault relationships of critical helicopter components, this invention does not employ a fixed propagation depth or fixed weights. Instead, it first calculates the fault association complexity of candidate relationships and then dynamically allocates graph propagation weights. The specific implementation is as follows: For candidate entity pairs Calculate indicators for each dimension, including local neighborhood density, number of multi-hop paths, relation ambiguity, strength of time dependency, and number of evidence sources, and process each indicator to a value range of [value range missing]. The standardized metrics are then weighted and summed to obtain the fault association complexity: ; in, For nodes With nodes The complexity of fault correlation between them; Represents the local neighborhood density; Indicates the number of multi-hop paths; Indicates the degree of ambiguity in the relationship; Indicates the strength of time dependence; It indicates the number of different sources of evidence supporting the relationship between the entities, reflecting the degree of cross-verification; All are non-negative weight coefficients, and satisfy the following conditions: .

[0049] Furthermore, let the initial fault relationship candidate graph be... ,in, For a set of nodes, Let be the set of edges corresponding to the candidate triples; Represents nodes The set of other nodes connected by the candidate triples, excluding nodes The local neighborhood density is calculated as follows: ; in, and Representing nodes respectively and nodes The number of neighboring nodes, This represents the total number of nodes in the initial fault relationship candidate graph.

[0050] make Represents a node With nodes The number of paths with a length of two or three hops. The expression for calculating the number of multi-hop paths is: ; When node With nodes When there is no two- or three-hop path between them, Correspondingly .

[0051] For relational ambiguity, let... For entity pairs The corresponding set of candidate relation types, For relation type The number of support counts obtained; the number of support counts refers to the support relation types among syntactic dependencies, trigger word patterns, temporal sequences, and source co-occurrence relations. The sum of the times, then the relation type support ratio for: ; in, It can be any relation type in the set of candidate relation types.

[0052] Furthermore, the degree of relational ambiguity is calculated as follows: ; in, The larger the value, the more dispersed the candidate relation types and the more uncertain the relations. The range of values ​​is .

[0053] For the strength of time dependence, let Represents a node With nodes The number of pieces of related evidence that have a clear chronological relationship and whose time interval is less than a preset time window is [number missing]. The time dependency strength represents the total number of pieces of evidence relating to the entity pair. The calculation expression is: ; Regarding the quantity of sources of evidence, let Indicates support node With nodes The number of different sources of association, The maximum number of distinct sources among all candidate entity pairs represents the number of distinct sources of evidence supporting the association between the entity pairs. The calculation expression is: ; Candidate entity pairs are generated from candidate triples, and the candidate triples retain evidence of association and source identifiers, therefore and .thus, , , , and All in Interval, Fault Association Complexity Also in Interval.

[0054] It should be noted that in the multi-dimensional index weighted summation step involved in this application, each index has undergone dimensional normalization before the weighted calculation to ensure that the value ranges of each index are consistent, thereby guaranteeing the objectivity of the weighted summation result. Dimensional normalization is a common technique in this field, and its specific implementation methods include, but are not limited to, range normalization and Z-score standardization, which can be flexibly selected according to the actual data characteristics. This application will not elaborate on this, but the dimensional normalization process has been performed before the multi-dimensional index weighted summation process described below.

[0055] Furthermore, graph attention weights are generated based on the fault association complexity. Let the nodes... The extended neighborhood set is: ; in, Indicates including nodes The set of its own extended neighborhood. For a node itself, let... This indicates that the node itself does not participate in the calculation of the fault association complexity between entity pairs.

[0056] Based on node representation vectors and fault association complexity, calculate node... For nodes Graph attention weights: ; in, This represents the layer index of a graph neural network; Represents a node For nodes In the Graph attention weights during layer updates; , and Representing nodes respectively ,node and nodes In the Layer representation vector; Represents a node With nodes The complexity of fault correlation between them Represents a node With nodes The complexity of fault correlation between them; Represents the extended neighborhood set Node index in; The scoring function maps the representation vectors of two nodes and their fault association complexity to a scalar score value. Perform message passing update again: ; in, For nodes exist Layer representation vector, For activation function, for Layer weight parameters, for Layer bias parameters; For nodes exist The layer's representation vector. It should be noted that due to the extended neighborhood set... Including the node itself, therefore the node The update not only aggregates the feature information of its first-order neighbor nodes, but also... Its own representation vector As part of the neighborhood information, it participates in the aggregation, thus in the updated representation vector It effectively preserves the original feature information of nodes.

[0057] After updating via message passing in the graph neural network, the representation vector of each node is obtained. For candidate triples... Using relational types Corresponding relation parameter matrix Score: ; in, The score for the triplet. For relationships between entities, For nodes Represents the transpose of a vector. For relation type The corresponding parameter matrix.

[0058] Specifically, the relational parameter matrix During the training phase, it is obtained from training triples labeled with relation type. Let... Let be the set of positive sample triples, which consists of historical relation records in the standardized data that already have relation type labels; let... The set of negative sample triples is formed by replacing the tail entity of the positive sample triples with an entity of the same category but not related to the head entity. Other entity generation.

[0059] For each relation type , the relation parameter matrix Initialize it as an identity matrix with the same dimension as the node representation vector. Let the dimension of the node representation vector be... ,but for A 3D matrix. A training loss function is constructed based on the sets of positive and negative sample triples. : ; in, Indicates the number of triples in the set of positive sample triples; Indicates the number of triples in the set of negative sample triples; This is the activation function.

[0060] The relation parameter matrix is ​​iteratively updated based on the training loss function: in, Indicates the number of training iterations; Indicates the first Relationship type at the next iteration The corresponding relational parameter matrix; Indicates the first The relational parameter matrix after the next iteration; This represents the preset update step size of the relational parameter matrix. The above training process uses a scoring function. Based on this, by minimizing the loss function Optimize the relation parameter matrix The parameters are used to learn relation types in an end-to-end manner. The scoring model is used. After training, the relation parameter matrix corresponding to each relation type is obtained. .

[0061] When scoring the current candidate triples, the training-completed relation type is called. Corresponding relation parameter matrix Calculate the candidate triple score .like , If the score threshold is set, then the relationship is written into the initial knowledge graph.

[0062] In one embodiment, to address the issues of synonyms, inconsistent granularity of representation, and mixed use of hierarchical and superordinate concepts for the same fault knowledge from different sources, cross-source semantic alignment processing is performed on the extraction results, i.e., candidate triples: (1) Construct a fault feature anchor point library. Anchor points are formed by a combination of component location, feature mode, operating conditions, and typical faults. Let the m-th anchor point template be... for: ; in For component location, For feature patterns, For operating condition constraints, For corresponding fault or damage labels.

[0063] (2) For any candidate entity or relation description z, calculate the matching score between the candidate entity or relation and the anchor template. : ; in, It can be a cosine similarity or edit distance normalized score. Component positions in candidate entities or relations For candidate entities or relations, feature patterns These are the working condition constraints in candidate entities or relationships. , , All are weighting coefficients.

[0064] (3) Using the domain adaptive semantic mapping model, the general semantic space is mapped to the helicopter fault domain semantic space to obtain the domain semantic vector, and the domain semantic similarity between the candidate triples and the predefined standard entities or standard relations in the anchor point library is calculated based on the domain semantic vector.

[0065] Among them, the domain-adaptive semantic mapping model can be a linear mapping layer, and the mapped vectors Represented as: ; in The original semantic vector, To adapt weight parameters to the domain, Adapt bias parameters to the domain.

[0066] (4) Fusion Anchor Matching Score Domain semantic similarity The standard entity or standard relation with the highest score that exceeds the threshold is used as the normalization result.

[0067] The expression for calculating the fusion of anchor point matching score and domain semantic similarity is as follows: ; in, To achieve a score based on integration, These are the weighting coefficients; Domain semantic vectors for standard entities or relations.

[0068] In this embodiment, anchor point matching provides physical symptom constraints, while domain semantic mapping provides flexible adaptation capabilities. The combination of the two can simultaneously ensure interpretability and generalization ability.

[0069] In one embodiment, after forming the fault knowledge graph to be optimized, the method further includes: (1) Construct a formal fault mechanism knowledge graph, including an entity layer, a relation layer and an evidence layer.

[0070] The entity layer includes at least one of the following: component, failure mode, symptom, damage, maintenance action, operating condition, and source of evidence; the relationship layer includes at least one of the following: subordinate, inducement, characterization, accompaniment, temporal evolution, maintenance target, and evidence support; the evidence layer includes at least one of the following: document fragment, monitoring data fragment, maintenance record, case number, and credibility score, where the case number is the identifier for each historical failure record in the failure case database.

[0071] Formal Fault Mechanism Knowledge Graph Recorded as: ; in, For a collection of entities, For a set of relations, For a set of triples, It is a set of evidence and attributes.

[0072] (2) Establish a degradation chain : ; in, This is an index of the degradation chain stages, which includes at least two stages: normal, minor wear, moderate wear, localized peeling, functional degradation, and failure.

[0073] (3) Define the degradation stage transition probability based on the working conditions and the stage transition scoring function, and update the degradation chain and transition probability to the fault knowledge graph to be optimized in order to describe the evolution law of the performance degradation process of key components.

[0074] Degeneration stage transition probability Represented as: in, , which is the index of the current stage of the degenerate chain; For operating conditions, For the stage transition scoring function, This serves as an index for the next stage.

[0075] In one embodiment, to address the issues of missing relationships, missing mechanism chains, and insufficient edge fault knowledge in the initial atlas, a self-learning inference engine based on reinforcement learning is designed. The self-learning completion mechanism includes: (1) The graph completion task is modeled as a sequence decision problem based on reinforcement learning.

[0076] (2) Define the environmental state Define actions for the entity node at the current inference moment, the path already traversed, and the local graph context. To select the next relationship and next-hop entity from the current node, and define the policy network based on the environment state and actions: ; The policy network outputs in the current state The following actions are permissible probability distribution .

[0077] (3) Use the probability distribution of each action output by the policy network, define the value function based on the reward obtained after the state transition, estimate the advantage function based on the value function, update the policy network parameters through the policy gradient based on the advantage function and the probability distribution output by the policy network, so as to train the policy network to have the ability to autonomously reason out the missing fault mechanism path, and use the policy network with updated parameters to mine the missing knowledge of the fault knowledge graph to be optimized, continuously complete and optimize the fault knowledge graph.

[0078] Specifically, a reward is obtained after the state transition. When the path generated by the current action successfully completes the missing knowledge and is consistent with the existing mechanism, the instant reward is given. The value is 1; the instant reward is given when the current action encounters an error loop, conflict, or low-reliability extension. The value is -1; in other cases, the instant reward The value is 0. The conditions for determining positive and negative rewards are mutually exclusive. Value function for: ; The expected value of the trajectory is the average of the policy distribution over all possible trajectories. As a discount factor, Indicates time step Beginning, then Instant rewards received after a certain number of time steps.

[0079] Based on the value functions of the current state and the next state after the state transition, the advantage function is estimated using a time-difference approach. : ; in, To perform the action The next state obtained after the transition; The value function for the next state; The value function of the current state; Used to characterize the gain of the expected reward of the current action relative to the current state.

[0080] Policy parameters are updated via policy gradient: ; in, Let the policy objective function be... For policy network parameters, To adjust the policy network parameters Find the gradient.

[0081] In one embodiment, to avoid increasing pseudo-knowledge by only pursuing the amount of map expansion, or making the completion too conservative by only pursuing local accuracy, a dual reward function is constructed regarding the map completeness improvement rate and the association accuracy rate, including the following steps: (1) Determine the graph completeness improvement rate based on the ratio of the number of newly added correct entities or relations to the total number of entities or relations in the graph before completion. : ; in, To complete the total number of correct entities or relations in the final graph, To complete the total number of entities or relations in the previous graph, To add the correct number of entities or relationships.

[0082] Alternatively, a weighted calculation can be performed on the connectivity of key entities and the closure of degenerate chains to obtain the map completeness improvement rate.

[0083] (2) Calculate the association accuracy bonus based on the ratio of the number of newly verified relations to the total number of newly added relations: ; in, To verify the number of newly added relations that have passed the verification, This represents the total number of newly added relationships.

[0084] (3) The completeness improvement rate, association accuracy rate and erroneous association penalty are weighted to obtain the total reward. : ; in, For error-related penalty items, This is the adjustment coefficient.

[0085] After generating new candidate triples in the current training round, each new candidate triple undergoes relational logic verification. If the head entity type or tail entity type of a candidate triple does not meet the preset type requirements for its candidate relation type, or if the candidate triple conflicts with an existing relation in the current fault knowledge graph, then the candidate triple is determined to be an incorrect association. Incorrect association penalty item. The calculation expression is: ; in, This represents the number of new candidate triples generated in the current training round. This represents the number of candidate triples identified as incorrect associations after relational logic verification. The total reward is only calculated during the training epochs where new candidate triples are generated; therefore... Greater than zero. The range of values ​​is The larger the value, the higher the proportion of erroneous associations generated in the current training round.

[0086] (4) After each round of training, the policy network, rule candidate pool and statistical prior model are updated synchronously according to the total reward.

[0087] The policy network is updated according to the policy gradient method described above.

[0088] For the candidate rules involved in generating candidate relations in the current training round, let the i-th rule be... The candidate rule score for the round is Then, based on the total reward, it will be updated as follows: ; in, For the first The candidate rule score for the round, Indicates the candidate rules, Indicates training rounds, Indicates the preset update step size. This represents the total reward for the current training round. A positive total reward increases the score of the corresponding candidate rule; a negative total reward decreases the score of the corresponding candidate rule. The updated rule score is used for rule ranking in the next round of candidate relation generation.

[0089] Statistical prior models use the frequency of occurrence of each relation type in verified relations as the prior probability. Let... Representing relation type In the The cumulative number of successful validations after each round of training. Indicates the type of relation in the current training round. If the number of verifications passes, then: ; in, For relation type In the Cumulative number of validation passes after rounds of training; updated relation type The prior probability is: in, Representing relation type The updated prior probability, This indicates the type of relation. When the total reward is positive, the relations that have passed the validation in the current training round are included in the statistical prior model; when the total reward is not positive, the relations in the current training round are not included in the statistical prior model.

[0090] Therefore, based on the total reward, the policy network, rule candidate pool, and statistical prior model are updated synchronously, and the missing knowledge mining and error association correction of the fault knowledge graph to be optimized are completed.

[0091] In one embodiment, to address the problem of the fault knowledge graph relying on regular manual updates and lacking timeliness, a proactive update process is constructed, encompassing real-time retrieval, intelligent generation, and verification before storage. Specifically, this proactive dynamic update mechanism includes: (1) Generate retrieval tasks based on weak knowledge areas, hot components, and recent abnormal cases to form a query set. : ; in, This represents the total number of queries. Weak knowledge regions are areas in the fault knowledge graph where the number of candidate triples connected to entity nodes is below a preset threshold, or where the number of relation types covered is below a preset type threshold. Hot components are component entities in the fault knowledge graph that rank highest in the number of associated fault cases within a preset time window; the number of fault cases is determined based on the number of historical fault records or evidence nodes connected to that component entity in the graph. Recent abnormal cases refer to monitoring data fragments that appear in real-time monitoring data and correspond to abnormal representations that do not match existing fault patterns in the graph.

[0092] (2) Retrieve candidate document sets from external data sources The data are then reordered based on relevance, source authority, and time relevance.

[0093] ; in, Indicates a search query; For the first 1 candidate document.

[0094] (3) Sort the top K documents As the generation context, input knowledge generation model Generate candidate knowledge entries Candidate knowledge entries are then written into the fault knowledge graph. (Generate candidate knowledge entries) The calculation expression is: .

[0095] Among them, candidate knowledge items This includes standardized fault descriptions, candidate entities, candidate relationships, applicable operating conditions, and evidence summaries. Optionally, the knowledge generation model can be implemented using a large language model based on a retrieval-enhanced generation architecture. The large language model can be a general-purpose large language model such as GPT-4 or ChatGLM.

[0096] In one embodiment, before writing candidate knowledge entries into the fault knowledge graph, the method further includes: (1) Select candidate entries Candidate entities, candidate relationships, and key parameters in the graph, and their connection to the core mechanism chain of existing graphs. The consistency score is calculated by comparing the range of key parameters and the hierarchical relationship of components. : ; in, The consistency flag for the core mechanism chain is set to 1 if the candidate triple corresponding to the candidate entry can be connected to the core mechanism chain without causing a relationship conflict, otherwise it is set to 0. For key parameter consistency indicator: 1 is set when the key parameter in the candidate entry is within the range of key parameters corresponding to the existing map, or when the existing map does not have a corresponding key parameter range set; otherwise, 0 is set. For component hierarchy consistency: 1 is assigned when the component hierarchy relationship between candidate entities is consistent with the component hierarchy relationship of the existing graph; otherwise, 0 is assigned. Consistency score. The range of values ​​is .

[0097] (2) Calculate the authenticity score based on whether there is a case number, source organization, original measurement point, maintenance record, or cross-verification from multiple sources. : ; in, For the first Weight of evidence by type; , indicating the first Does such evidence exist? Let be the number of evidence categories; the weight of each piece of evidence is a non-negative number, and satisfies . ,therefore The range of values ​​is .

[0098] (3) Calculate the sufficiency score of evidence based on the quantity, type diversity, temporal continuity and source reliability of the evidence. : ; in, This is used to indicate the number of pieces of evidence; it is set to 1 when there are at least two pieces of evidence supporting a candidate entry, and 0 otherwise. The type diversity indicator is set to 1 when the evidence comes from at least two different types, and 0 otherwise. As a time continuity indicator, it is set to 1 when the evidence record has a clear temporal logic (such as the time when the fault symptoms appear is earlier than the time when the fault mode is confirmed, and the time when the maintenance measures are implemented is later than the time when the fault is diagnosed) and there is no contradictory temporal relationship; otherwise, it is set to 0. As an indicator of source reliability, it is set to 1 when the evidence contains at least one of the following: source organization, original measurement point, maintenance record, or cross-verification from multiple sources, and can be associated with a specific case number; otherwise, it is set to 0. The range of values ​​is .

[0099] Candidate items are calculated based on consistency score, authenticity score, and sufficiency of evidence score. Overall credibility : ; in, This is the consistency weighting coefficient. This is the authenticity weighting coefficient. These are sufficiency weighting coefficients, all of which are non-negative and satisfy the following conditions: .

[0100] (4) When the overall credibility of candidate items If the threshold is not lower than a preset threshold, candidate knowledge entries are automatically supplemented with standard fields and written into the knowledge graph. Specifically, using the standardized head entity, relation, tail entity, and applicable working condition as matching conditions, corresponding entity nodes and relation edges are searched in the existing knowledge graph; for entities that do not exist, corresponding entity nodes are created; for relation edges that do not exist, a relation edge between the head entity and the tail entity is established, and the applicable working condition, source identifier, credibility, knowledge version number, and timestamp are written into it; for existing relation edges of the same type, the newly added source identifier, credibility, knowledge version number, and timestamp are added to the evidence record of that relation edge. The standard fields include head entity, relation, tail entity, applicable working condition, source identifier, credibility, knowledge version number, and timestamp. Otherwise, candidate knowledge entries are written into the pending review area. Optionally, for candidate knowledge entries to be written into the pending review area, a decision can be made after manual review and confirmation, or consistency verification (consistency score calculation), authenticity verification (authenticity score calculation), and evidence sufficiency assessment (evidence sufficiency score calculation) can be re-executed in the next round of proactive dynamic updates. If the conditions are met, the entries will be automatically written into the knowledge graph.

[0101] Combining the above embodiments yields a preferred embodiment of the present invention, in which the solution includes the following steps: S10: Acquire multi-source fault data related to the target key components, perform noise reduction, field alignment, unit unification and preliminary semantic normalization on the multi-source fault data, and convert it into standardized data in a unified format.

[0102] S20: Identify entities and relationships from standardized data and construct an initial candidate graph of fault relationships.

[0103] Cross-source semantic alignment is performed on candidate triples in the initial fault relationship candidate graph to construct a fault feature anchor point library. The matching score between candidate entities or candidate relations and anchor point templates is calculated. Using a domain adaptive semantic mapping model, the general semantic space is mapped to the helicopter fault domain semantic space to obtain domain semantic vectors. Based on the domain semantic vectors, the domain semantic similarity between candidate triples and predefined standard entities or standard relations in the anchor point library is calculated. The matching score and domain semantic similarity are fused, and the standard entity or standard relation with the highest score and exceeding the threshold is taken as the normalization result.

[0104] The fault association complexity between candidate entity pairs in the initial fault relationship candidate graph is calculated. The graph attention weights are dynamically allocated according to the fault association complexity. The message passing update of the graph neural network is performed based on the graph attention weights. The candidate triples are scored. The candidate triples whose scores meet the score threshold are written into the initial knowledge graph to form the fault knowledge graph to be optimized.

[0105] A formal fault mechanism knowledge graph is constructed, including an entity layer, a relation layer, and an evidence layer; a degradation chain is established, which includes at least two stages from normal, slight wear, moderate wear, local spalling, functional degradation, and failure; the degradation stage transition probability is defined based on operating conditions and a stage transition scoring function, and the degradation chain and transition probability are integrated into the fault knowledge graph to be optimized to describe the evolution law of the performance degradation process of key components.

[0106] S30: A self-learning completion mechanism is used to mine missing knowledge and correct erroneous associations in the fault knowledge graph to be optimized, including: The graph completion task is modeled as a sequential decision-making problem based on reinforcement learning. The environment state is defined as the entity node at the current inference time, the path already visited, and the local graph context. The action is defined as selecting the next relation and the next hop entity from the current node. A policy network is defined based on the environment state and the action. The probability distribution of each action is output by the policy network. A value function is defined based on the reward obtained after the state transition. The advantage function is estimated based on the value function. The policy network parameters are updated through policy gradient based on the advantage function and the probability distribution output by the policy network. The missing knowledge is mined from the fault knowledge graph to be optimized using the policy network with updated parameters. The total reward is obtained by weighting the completeness improvement rate, association accuracy rate and erroneous association penalty. The policy network, rule candidate pool and statistical prior model are updated synchronously according to the total reward to complete the missing knowledge mining and erroneous association correction of the fault knowledge graph to be optimized.

[0107] S40: The corrected fault knowledge graph is iteratively updated in real time through an active dynamic update mechanism, outputting an optimized fault knowledge graph, including: A query set is formed by generating retrieval tasks around weak knowledge areas, hot components and recent abnormal cases. A candidate document set is recalled from external data sources and reordered according to relevance, source authority and time relevance. The top-ranked documents are used as the generation context and input into the knowledge generation model to generate candidate knowledge entries. The system performs consistency checks, authenticity verifications, and evidence sufficiency assessments on candidate knowledge entries. Candidate knowledge entries that pass multiple checks are automatically supplemented with standard fields and written into the knowledge graph, enabling proactive dynamic iteration of the graph.

[0108] The method of this invention adopts a full-process self-learning closed-loop design, which includes an adaptive data preprocessing step S10, a dynamic knowledge extraction and fusion step S20, a reinforcement learning-driven self-learning completion step S30, and a retrieval-enhanced proactive update step S40. The modules work together to realize the automated, high-precision construction and dynamic iteration of the fault mechanism knowledge graph.

[0109] Specifically, by employing a fault adaptive data cleaning model and a dynamic weight adjustment knowledge extraction algorithm, fully automated and standardized processing of diverse and heterogeneous fault data is achieved. This accurately identifies complex fault causal relationships, significantly improves knowledge fusion accuracy, drastically reduces manual costs, and enhances the efficiency and fundamental quality of knowledge graph construction. Through a reinforcement learning-driven self-learning completion mechanism, the system proactively mines missing knowledge and autonomously corrects erroneous associations. It possesses self-learning characteristics that continuously optimize with the accumulation of fault knowledge, effectively improving the completeness and accuracy of the knowledge graph and completely resolving the problems of incomplete information and the need for manual review and correction in existing knowledge graphs. By constructing a proactive dynamic update closed loop, the system overcomes the timeliness bottleneck of existing static knowledge graphs. Through retrieval-enhanced generation technology and a credibility verification mechanism, real-time capture and uninterrupted updates of fault knowledge are achieved. This ensures that the knowledge system always matches the latest research results and field fault cases, providing dynamic and accurate knowledge support for helicopter fault diagnosis, effectively reducing the rate of missed and false fault diagnoses, and improving the level of diagnostic intelligence.

[0110] The self-learning closed-loop design method of this invention has strong adaptability, can adapt to the differences in fault characteristics of different key components of helicopters, does not require targeted adjustment of the core algorithm, has strong scalability, and can be directly transferred to other fault knowledge graph construction scenarios of aviation power machinery.

[0111] This invention also provides a computer program product, including a computer program that, when executed by a processor, implements the steps of the self-learning construction and optimization method for a helicopter fault knowledge graph formed by any or a combination of the above examples. The processor may be a single-core or multi-core central processing unit or a specific integrated circuit, or one or more integrated circuits configured to implement this invention.

[0112] The present invention also provides a storage medium having the same inventive concept as the self-learning construction and optimization method for helicopter fault knowledge graph formed by any or more of the above examples, wherein computer instructions are stored thereon, and the computer instructions, when executed, perform the steps of the self-learning construction and optimization method for helicopter fault knowledge graph formed by any or more of the above examples.

[0113] Based on this understanding, the technical solution of this embodiment, or the part that contributes to the prior art, or a part of the technical solution, can be embodied in the form of a software product. This computer software product is stored in a storage medium and includes several instructions to cause a computer device (which may be a personal computer, server, or network device, etc.) to execute all or part of the steps of the methods described in the various embodiments of this invention. The aforementioned storage medium includes various media capable of storing program code, such as USB flash drives, portable hard drives, read-only memory (ROM), random access memory (RAM), magnetic disks, or optical disks.

[0114] This invention also provides a terminal that shares the same inventive concept as any or a combination of examples corresponding to the aforementioned self-learning construction and optimization method for helicopter fault knowledge graphs. The terminal includes a memory and a processor. The memory stores computer instructions executable on the processor. When the processor executes the computer instructions, it performs the steps of the aforementioned self-learning construction and optimization method for helicopter fault knowledge graphs. The processor may be a single-core or multi-core central processing unit or a specific integrated circuit, or one or more integrated circuits configured to implement this invention.

[0115] In one example, the terminal, i.e., the electronic device, is represented in the form of a general-purpose computing device. The components of the electronic device may include, but are not limited to: at least one processing unit (processor) mentioned above, at least one storage unit mentioned above, and a bus connecting different system components (including storage units and processing units).

[0116] The storage unit stores program code that can be executed by the processing unit, causing the processing unit to perform the steps described in the "Exemplary Methods" section above, based on various exemplary embodiments of the present invention. For example, the processing unit can execute the aforementioned self-learning construction and optimization method for a helicopter fault knowledge graph.

[0117] The storage unit may include readable media in the form of volatile storage units, such as random access memory (RAM) and / or cache storage units, and may further include read-only memory (ROM).

[0118] The storage unit may also include a program / utility having a set (at least one) of program modules, 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.

[0119] A bus can represent one or more of several types of bus structures, including a memory cell bus or memory cell controller, a peripheral bus, a graphics acceleration port, a processing unit, or a local bus that uses any of the various bus structures.

[0120] The electronic device can also communicate with one or more external devices (e.g., keyboards, pointing devices, Bluetooth devices, etc.), one or more devices that enable a user to interact with the electronic device, and / or any device that enables the electronic device to communicate with one or more other computing devices (e.g., routers, modems, etc.). This communication can be performed via input / output (I / O) interfaces. Furthermore, the electronic device can communicate with one or more networks (e.g., local area networks (LANs), wide area networks (WANs), and / or public networks, such as the Internet) via a network adapter. The network adapter communicates with other modules of the electronic device via a bus. It should be understood that other hardware and / or software modules can be used in conjunction with the electronic device, including but not limited to: microcode, device drivers, redundant processing units, external disk drive arrays, RAID systems, tape drives, and data backup storage systems.

[0121] Through the above description, those skilled in the art will readily understand that the exemplary embodiments described herein can be implemented by software or by combining software with necessary hardware. Therefore, the technical solution according to this exemplary embodiment can be embodied in the form of a software product, which can be stored in a non-volatile storage medium (such as a CD-ROM, USB flash drive, external hard drive, etc.) or on a network, including several instructions to cause a computing device (such as a personal computer, server, terminal device, or network device, etc.) to execute the method of the exemplary embodiment of this application.

[0122] The above detailed embodiments are a description of the present invention. It should not be considered that the specific embodiments of the present invention are limited to these descriptions. For those skilled in the art, several simple deductions and substitutions can be made without departing from the concept of the present invention, and all of these should be considered to fall within the protection scope of the present invention.

Claims

1. A self-learning construction and optimization method for helicopter fault knowledge graphs, characterized in that, Includes the following steps: Acquire multi-source fault data related to the target critical components and preprocess it, converting the multi-source fault data into standardized data in a unified format; Entities are identified from standardized data, including component entities, fault mode entities, fault symptom entities, operating condition entities, damage form entities, maintenance measure entities, time entities, and evidence source entities. Candidate triples are generated based on syntactic dependencies, trigger word patterns, temporal sequences, and source co-occurrence relationships. The identified entities are used as nodes, and the candidate triples are used as edges to construct an initial fault relationship candidate graph. The head and tail entities in the candidate triples constitute candidate entity pairs. The fault association complexity between candidate entity pairs in the initial fault relationship candidate graph is calculated. The graph attention weights are dynamically allocated according to the fault association complexity. The message passing update of the graph neural network is performed based on the graph attention weights. The candidate triples are scored. The candidate triples whose scores meet the score threshold are written into the initial knowledge graph to form the fault knowledge graph to be optimized. The fault knowledge graph to be optimized is improved by a self-learning completion mechanism to mine missing knowledge and correct erroneous associations. The corrected fault knowledge graph is iteratively updated in real time through an active dynamic update mechanism, and an optimized fault knowledge graph is output.

2. The self-learning construction and optimization method for helicopter fault knowledge graphs according to claim 1, characterized in that, The method also includes cross-source semantic alignment processing for candidate triples: Construct a fault feature anchor point library, where anchor points include component location, feature mode, operating conditions, and typical faults; Calculate the matching score between candidate entities or candidate relations and anchor templates, where candidate relations are the relation types in candidate triples; Using a domain-adaptive semantic mapping model, the general semantic space is mapped to the helicopter fault domain semantic space to obtain domain semantic vectors. Based on the domain semantic vectors, the domain semantic similarity between candidate triples and predefined standard entities or standard relations in the anchor point library is calculated. The matching score and domain semantic similarity are combined, and the standard entity or standard relationship with the highest score that exceeds the threshold is used as the normalization result.

3. The self-learning construction and optimization method for helicopter fault knowledge graphs according to claim 1, characterized in that, After forming the fault knowledge graph to be optimized, the process also includes: Construct a formal knowledge graph of failure mechanisms, including an entity layer, a relation layer, and an evidence layer; Establish a degradation chain, which includes at least two stages: normal, slight wear, moderate wear, localized peeling, functional degradation, and failure. Based on the operating conditions and the stage transition scoring function, the degradation stage transition probability is defined, and the degradation chain and transition probability are updated to the fault knowledge graph to be optimized.

4. The self-learning construction and optimization method for helicopter fault knowledge graphs according to claim 1, characterized in that, The self-learning completion mechanism includes: The graph completion task is modeled as a sequence decision problem based on reinforcement learning; The environment state is defined as the entity node at the current inference time, the path already traversed, and the local graph context. The action is defined as selecting the next relation and the next hop entity from the current node. The policy network is defined based on the environment state and the action. The probability distribution of each action is output by the policy network. A value function is defined based on the reward obtained after the state transition. The advantage function is estimated based on the value function. The policy network parameters are updated through policy gradient based on the advantage function and the probability distribution output by the policy network. The missing knowledge is mined from the fault knowledge graph to be optimized using the policy network with updated parameters.

5. The self-learning construction and optimization method for helicopter fault knowledge graphs according to claim 4, characterized in that, The self-learning completion mechanism also includes: The graph completeness improvement rate can be determined by the ratio of the number of newly added correct entities or relations to the total number of entities or relations in the graph before completion, or by weighting the connectivity of key entities and the closure of degenerate chains to obtain the graph completeness improvement rate. The association accuracy bonus is calculated based on the ratio of the number of newly verified relationships to the total number of newly added relationships. The total reward is obtained by weighting the completeness improvement rate, the association accuracy rate, and the incorrect association penalty. Based on the total reward, the strategy network, rule candidate pool, and statistical prior model are updated synchronously to complete the missing knowledge mining and error association correction of the fault knowledge graph to be optimized.

6. The self-learning construction and optimization method for helicopter fault knowledge graph according to claim 1, characterized in that, The proactive dynamic update mechanism includes: Retrieval tasks are generated based on areas of weak knowledge, hot components, and recent abnormal cases, forming a query set; Retrieve a set of candidate documents from external data sources and reorder them based on relevance, source authority, and recentity. The top-ranked documents are used as the generation context, input into the knowledge generation model to generate candidate knowledge entries, and then written into the fault knowledge graph.

7. The self-learning construction and optimization method for helicopter fault knowledge graphs according to claim 6, characterized in that, Before writing candidate knowledge entries into the fault knowledge graph, the process also includes: The candidate entries are compared with the core mechanism chain, key parameter range, and component hierarchy of the existing graph, and a consistency score is calculated. The authenticity score is calculated based on whether there is a case number, source organization, original measurement point, maintenance record, or cross-verification from multiple sources. The sufficiency score of evidence is calculated based on the quantity, diversity of types, continuity of time, and reliability of sources. When the weighted sum of the consistency score, authenticity score, and evidence sufficiency score exceeds a preset threshold, the candidate knowledge item is written into the knowledge graph.

8. A computer program product, comprising a computer program, characterized in that, When the computer program is executed by the processor, it implements the steps of the self-learning construction and optimization method for helicopter fault knowledge graphs as described in any one of claims 1-7.

9. A storage medium storing computer instructions thereon, characterized in that, When the computer instructions are executed, they perform the steps of the self-learning construction and optimization method for helicopter fault knowledge graphs as described in any one of claims 1-7.

10. A terminal comprising a memory and a processor, wherein the memory stores computer instructions executable on the processor, characterized in that, When the processor executes the computer instructions, it performs the steps of the self-learning construction and optimization method for helicopter fault knowledge graphs as described in any one of claims 1-7.

Images