Undercarriage fault system based on graph neural network and knowledge graph, construction method and application

Abstract

The invention discloses an undercarriage fault system based on a graph neural network and a knowledge graph, a construction method and application, and relates to the technical field of computer deep learning and knowledge graphs. The construction method of the undercarriage fault system comprises the steps of data collection, data preprocessing, entity-relation extraction model training, knowledge graph construction, GAT network training and the like. The obtained undercarriage fault system can complete an undercarriage fault diagnosis task more efficiently and accurately.

Description

Technical Field

[0001] The present invention relates to the technical fields of computer deep learning and knowledge graph, and particularly relates to a landing gear fault system, a construction method and an application based on a graph neural network and a knowledge graph. Background Art

[0002] In terms of its classification, fault diagnosis technology can be roughly divided into three categories: methods based on analytical models, methods based on signal processing, and knowledge-based intelligent fault diagnosis methods. With the rapid progress of computer technology, knowledge-based intelligent fault diagnosis technology is also gradually developing. For example, the patent application with the application number "202211656613.1" and the name "A Fault Diagnosis Method and Device Based on a Knowledge Graph", which was published on March 17, 2023, mainly realizes entity extraction based on a trained extraction model and performs matching based on preset diagnosis rules to give association suggestions; another example is the patent application with the application number "202210987528.7" and the name "A Fault Diagnosis Method for Analog Circuits Based on a Graph Neural Network", which was published on November 4, 2022. When constructing a fault sample graph, the structural features between samples form constraints between structures. When the graph neural network processes the fault sample graph, it extracts the structural features and data features of the samples to classify the fault states of the samples to achieve fault diagnosis. However, in industrial applications, knowledge-based intelligent fault diagnosis technology still lacks feasible engineering methods.

[0003] The landing gear system is an important mechanical component to ensure flight safety. Due to its complex mechanical structure and the interaction between multiple components, it is prone to failures, affecting flight safety. For example, for the fault system of an aircraft landing gear, how to quickly and effectively diagnose the cause of the landing gear failure is an important means to ensure flight safety. Traditional diagnosis based on manual inspection, rule matching, or a single fault knowledge graph often has disadvantages such as low efficiency, incomplete coverage, and inability to diagnose and infer faults that have not occurred before. Summary of the Invention

[0004] The purpose of the present invention is to solve the above technical problems, and provide a landing gear fault system, a construction method and an application based on a graph neural network and a knowledge graph. By using a method combining a graph neural network and a knowledge graph, it makes up for the situation that traditional knowledge graphs cannot effectively diagnose faults that do not exist in the knowledge graph. Compared with traditional graph diagnosis, this landing gear fault diagnosis system can complete the landing gear fault diagnosis task more efficiently and accurately.

[0005] The present invention is achieved through the following technical solutions: A construction method for a landing gear fault system based on a graph neural network and a knowledge graph, comprising the following steps: S1. Data collection: Collect relevant historical data on landing gear failures, integrate various types of historical failure data, and use it as the data source for constructing a landing gear failure knowledge graph; S2. Data preprocessing: Preprocess the data source in step S1. The preprocessing includes formatting the data source and information extraction; S3. Train the entity-relation extraction model: Use the neural network-based entity-relation extraction model SpERT to complete the automatic extraction of graph nodes, and obtain the RDF triple data of entity-relation-entity; S4. Construct the knowledge graph: According to steps S2 and S4, store the constructed node and relationship knowledge in the Neo4j graph database to construct a knowledge graph based on landing gear failure data; S5. Train the GAT network: Use the GAT network as the basic model to train and obtain node features. The input of the GAT model includes the feature matrix of all nodes and the adjacency matrix of the knowledge graph; the optimization objectives of the GAT model include classification cross-entropy and minimizing the cosine similarity between the current node and all its neighbor nodes, and obtain the optimized GAT network model.

[0006] Furthermore, in step S1, the relevant historical data includes failure data such as maintenance manuals and inspection records. The failure data includes failure time, failed components, component symptoms, failure descriptions, and failure causes, etc. Among them: the failure parts include shock absorbers, force-bearing struts, retraction mechanisms, etc.; the component symptoms include vibration, oil leakage, etc.

[0007] Furthermore, in step S2, the formatting method is: convert files with inconsistent fonts and encodings into text files with a unified encoding format; for information extraction, the construction of the failure knowledge graph involves multiple types of entity nodes such as failed components and component symptoms. Therefore, it is necessary to extract the failure knowledge from the original historical files (such as excel, docx, doc, PDF) and use it as the training data for the entity-relation extraction model.

[0008] Furthermore, in step S3, in order to further improve efficiency, it is necessary to use the neural network-based entity-relation extraction model SpERT (Span-based Entity and Relation Transformer) to complete the automatic extraction of graph nodes. This model is based on the pre-trained model BERT, and is an entity and relation extraction model that combines entity and relation position information, and performs well in tasks such as relation extraction and joint extraction.

[0009] Artificial entity-relationship dataset construction is carried out in advance, that is, the original fault data is divided into multiple types of entities such as faulty components, component symptoms, fault descriptions, and fault causes. The relationships can be expressed as: faulty component —— (occurrence) —— component symptom, faulty component —— (cause) —— fault description, fault cause —— (lead to) —— fault description, etc. From this, RDF (Resource Description Framework) triples of entity-relationship-entity can be obtained for the training of the SpERT model.

[0010] Based on the trained SpERT model, entity lists of multiple types of entities such as faulty components, component symptoms, and fault descriptions can be extracted, including the corresponding relationships between entities. Based on this data, the construction of the fault knowledge graph is completed.

[0011] In data preprocessing, an entity list containing nodes such as fault locations and symptoms is obtained through information extraction, which provides a vocabulary basis for constructing the nodes of the knowledge graph. Based on the self-trained entity-relationship extraction model, RDF triple data of entity-relationship-entity can be extracted from the fault description.

[0012] Furthermore, in step S4, the specific method for constructing a knowledge graph based on landing gear fault data is as follows: S4.1. Store the constructed node and relationship knowledge in the Neo4j graph database; S4.2. Manage nodes and relationship edges through the Cypher declarative query language; S4.3. Neo4j provides a visualization tool to visually check the construction effect of the knowledge graph; S4.4. The interface between Neo4j and deep learning frameworks such as TensorFlow provides technical support for subsequent graph representation learning; S4.5. Based on the Neo4j graph database, construct a knowledge graph based on landing gear fault data.

[0013] For step S5, the present invention selects GAT as the basic model for training to obtain node features.

[0014] Among them, the input of the GAT model: First, the input of the GAT network includes a total of two parts. The first is the feature matrix X of all nodes, where each row corresponds to the feature representation of a node; the second is the adjacency matrix I of the knowledge graph, which is used to represent the network structure information of the entire graph. Through information such as the attributes, names, and categories of nodes, the vector representation of each entity node is initialized and limited to a fixed length.

[0015] Optimization objectives of the GAT model: First, the classification cross-entropy. Since each entity node has a corresponding category: component, symptom, fault description, etc., the feature learning of the target node can be achieved based on the classification cross-entropy; second, minimize the cosine similarity between the current node and all its neighbor nodes.

[0016] Based on the dual loss function, the current node and the same-type nodes among the neighbor nodes can be made closer, and at the same time, the network structure information can be more effectively extracted, making the obtained node feature representations more relevant.

[0017] Furthermore, in step S5, the method of using the GAT network as the basic model to train and obtain node features is as follows: S5.1.1. When the GAT updates the node representation, it can incorporate the network structure information. The first-order neighbor nodes of node i are the main participants in updating the current node representation, and the attention coefficient satisfies the following relational expression (1). (1) Among them, W represents the shared parameter matrix, which is used to map the feature representation of the node; h i and h j respectively represent the features of node i and node j ; The symbol || represents the concatenation operation, that is, the feature representations of node i and node j are concatenated; a(.) represents the mapping operation, that is, the concatenated vector is mapped to a real number. N i represents the set of neighbor nodes of node i .

[0018] S5.1.2. After the attention coefficient is calculated, normalization processing is performed, satisfying the following relational expression (2). (2) Among them, LeakReLU represents the variant of the non-linear activation function Relu ; α ij then represents the weight coefficient after normalization. The entire formula corresponds to the softmax function in deep learning; S5.1.3. Weightedly sum the attention coefficient vector corresponding to the neighbor nodes of node i and the feature matrix of the neighbor nodes to obtain node iThe updated feature representation satisfies the following relation (3): (3), where h i ´ represents the feature representation of the node after weighted summation (incorporating neighborhood node information); i σ(.) represents the activation function.

[0019] Furthermore, multi-head graph attention is used to obtain node representations from multiple perspectives, satisfying the following relation (4): (4), where K represents the number of heads of multi-head graph attention; || represents the concatenation operation; a(.) represents the mapping function, that is, after concatenating the node representations obtained by multiple single-head graph attentions and then passing through a mapping layer (linear layer) to map back to the original dimensional size, the node feature representation of the multi-head attention that fuses multiple perspectives can be obtained.

[0020] Furthermore, in step S5, the method for optimizing the objective of the GAT model is as follows: S5.2.1. The first loss during the training of the GAT network is that node classification aims to minimize the gap between the predicted label and the true label with the node's class label as the target, making nodes of the same class closer in the vector space, satisfying the following relation (5): (5); where C represents the number of node classes; N represents the number of nodes; y i c represents the i -th component of the true label of the c -th node; p i c represents the c -th component of the label predicted by the model; L cls represents the cross-entropy loss of all node classifications; S5.2.2. The second loss function of GAT is the cosine similarity loss between the current node and its neighbor nodes, satisfying the following relation (6): (6), where​cosin_similarity(h i ,h j ) Represents the cosine similarity of the embedding representations of the computing nodes i and nodes j where j is i one of the neighbor nodes of S5.2.3. The total objective loss function of GAT is: L = l cls + L consin .

[0021] An undercarriage fault system based on a graph neural network and a knowledge graph obtained by using the foregoing construction method.

[0022] Application of the foregoing undercarriage fault system in undercarriage fault diagnosis.

[0023] Application of the undercarriage fault system in undercarriage fault diagnosis, including the following steps: ①. According to the user input information, entity extraction is completed through the trained SpERT model to obtain entity nodes; ②. Based on the entity nodes in step ①, combined with the knowledge graph constructed based on the undercarriage fault data in step S4, knowledge graph retrieval matching and vector matching based on GAT are completed to obtain a diagnosis result.

[0024] Further, in step ②, it is retrieved whether the entity node exists in the fault knowledge graph, Ⅰ. If it exists, the fault description node associated with it is determined, and the fault description with the highest score and the associated fault cause are determined from the union set; Ⅱ. If it does not exist, the similarity between the node embedding representation obtained after training through the GAT network and the user problem query node is calculated. When the similarity between the node to be queried and the node representation in GAT exceeds the threshold, this node is placed in the candidate set. After completion of the matching, the fault description node associated with the node in the candidate set is queried, and each fault description node is scored according to the number of occurrences, and the query diagnosis result is returned from high to low according to the score.

[0025] Further, the threshold is 0.8.

[0026] Compared with the prior art, the present invention has the following advantages and beneficial effects: 1. In the present invention, the undercarriage fault diagnosis system based on a graph neural network and a knowledge graph obtained by using the construction method can handle the situation where traditional knowledge graphs cannot reason and diagnose faults that do not exist in the knowledge graph.

[0027] Second, in the present invention, the entity nodes learned based on the GAT network represent not only their own attribute information but also incorporate the network structure, enhancing the accuracy of fault diagnosis.

[0028] Third, in the present invention, the method combining graph neural network and knowledge graph can achieve multi-step reasoning, no longer limited to directly associated graph information, making the method more generalizable.

[0029] Fourth, in the present invention, the landing gear fault diagnosis system based on graph neural network and knowledge graph can not only make full use of the knowledge graph data summarized by domain experts for diagnosis but also perform multi-step association reasoning to find implicit associations not explicitly pointed out in the knowledge graph. Compared with traditional rule systems, the fault diagnosis system constructed by this method is more extensible and can adapt to system upgrades and new faults. This landing gear fault diagnosis system and its construction method and application will promote the development of intelligent maintenance technology and directly serve to improve the reliability and maintainability of landing gear fault diagnosis. It is of great significance for reducing the time and cost of landing gear fault diagnosis and repair. BRIEF DESCRIPTION OF THE DRAWINGS

[0030] Figure 1 is the construction flow chart of the fault diagnosis system based on graph neural network and knowledge graph.

[0031] Figure 2 is the schematic diagram of the graph data structure involved in the experimental process of Example 1.

[0032] Figure 3 is the flow chart of fault diagnosis using the fault diagnosis system in Example 1. DETAILED DESCRIPTION OF THE EMBODIMENTS

[0033] The present invention will be further described in detail below in conjunction with embodiments, but the implementation manners of the present invention are not limited thereto.

[0034] It should be noted that the following detailed descriptions are all exemplary and are intended to further introduce the present invention. Unless otherwise specified, all technical and scientific terms used in the present invention have the same meaning as commonly understood by those of ordinary skill in the technical field to which the present invention belongs.

[0035] The present invention specifically relates to a fault diagnosis system based on graph neural network and knowledge graph, mainly including: fault diagnosis data collection, data preprocessing, training of entity-relationship extraction model, construction of knowledge graph, training of GAT network, and GAT-based auxiliary diagnosis and other modules.

[0036] Specifically, for ease of understanding, the following describes the solution of the present invention in detail with reference to the accompanying drawings.

[0037] Example 1 The landing gear fault system based on the graph neural network and the knowledge graph refers to Figure 1 , and includes the following steps: S1. Data collection: Collect the landing gear fault data sorted out from relevant documents, including maintenance manuals and inspection records, and decompose various entities such as fault components, component symptoms, and fault descriptions from them, as well as the attribute information of each type of entity, such as the name and size of the fault component.

[0038] S2. Data preprocessing: Perform operations such as encoding format conversion and fault text extraction on the sorted files containing fault data, and leave the extracted fault-related data as the training data for the subsequent entity-relationship extraction model.

[0039] S3. Train the entity-relationship extraction model.

[0040] First, perform entity-relationship annotation: Use an open-source annotation tool to perform entity-relationship annotation on the extracted fault text, which is used as the training data for the entity-relationship extraction model SpERT.

[0041] Furthermore, based on the already annotated landing gear fault data set, train the entity-relationship extraction model SpERT for landing gear faults. Specifically, the SpERT model is based on the pre-trained model BERT and includes an embedding layer, an encoding layer, and a classification layer. The embedding layer obtains the text embedding representation based on the pre-trained BERT, the encoding layer updates the embedding representation based on the attention mechanism and LSTM, and the classification layer completes entity classification based on the neural network.

[0042] Finally, based on the trained SpERT model, it can be used as an entity-relationship extraction tool for unannotated fault data, and multiple fault RDFs can be obtained, and the category information of each entity node can be obtained at the same time.

[0043] S4. Construct a knowledge graph.

[0044] Based on the entity list extracted by the SpERT model and the corresponding RDF triples, a fault knowledge graph based on landing gear data can be constructed. Storing the processed entity node list and RDF in the Neo4j graph database can complete the construction of the graph.

[0045] This fault knowledge graph includes multiple types of entity nodes such as fault components, component symptoms, and fault descriptions, and each type of node has corresponding attribute information. And "fault description" and "fault cause" are the information that users are concerned about.

[0046] S5. Train the GAT network.

[0047] When dealing with graph-structured data, traditional neural network models are no longer applicable. Graph neural network models can retain complex network structure information while training to obtain node features. The fault knowledge graph itself belongs to a graph network, where each node corresponds to an entity node, and there are edges connecting the nodes. Based on this fault graph network, fault diagnosis and analysis can be achieved.

[0048] Compared with ordinary graph neural networks, the GAT network incorporates the attention mechanism and is better able to capture the complex structure information of the graph network. Since the network structure is extremely important for fault reasoning, the GAT is selected as the basic model for training to obtain node features in this embodiment.

[0049] The specific operation method is as follows: First, initialize the model input, including the vector representation of each node and the adjacency matrix of the fault knowledge graph. The initial representation of each entity node is obtained according to the attribute information of each entity node, and the adjacency matrix contains the structure information of the entire graph network.

[0050] Secondly, training the GAT network requires obtaining the feature representations of each node based on graph attention. When updating the node representation, the GAT can incorporate the network structure information. As shown in the network structure, the first-order neighbor nodes of node Figure 2 are the main participants in updating the current node representation. The calculation formula for the attention coefficient is as follows: i where W represents the shared parameter matrix used to map the feature representation of the node; h i and h j represent the features of node i and node j respectively, the symbol || represents the concatenation operation, that is, the feature representations of node i and node j are concatenated; a(.) represents the mapping operation, that is, mapping the concatenated vector to a real number, N i represents the set of neighbor nodes of node i .

[0051] After the attention coefficient is calculated, normalization is required, that is, the sum of the attention coefficients of all first-order neighbor nodes of node i is equal to 1, and its formula is as follows: whereLeakReLU represents a variant of the non-linear activation function Relu , α ij represents the weight coefficient after normalization. The entire formula corresponds to the softmax function in deep learning.

[0052] By performing a weighted sum of the attention coefficient vectors corresponding to the neighbor nodes of node i and the feature matrix of the neighbor nodes, the updated feature representation of node i can be obtained. The weighted sum formula is as follows: , where h i ´ represents the feature representation of node i after weighted sum (incorporating neighborhood node information); σ(.) represents the activation function.

[0053] To capture richer semantic information, in the experiments of the present invention, single-head attention is replaced with multi-head graph attention to obtain node representations from multiple perspectives. The formula is as follows: , where K represents the number of heads of the multi-head graph attention; || represents the concatenation operation; a(.) represents a mapping function, that is, after concatenating the node representations obtained from multiple single-head graph attentions and then passing through a mapping layer (linear layer) to map back to the original dimension size, the node feature representation of the multi-head attention integrating multiple perspectives can be obtained.

[0054] The goal of the GAT network is to continuously update the feature representation of the current node for subsequent fault matching. Thus, in this embodiment, the first loss in training the GAT network is node classification, that is, minimizing the gap between the predicted label and the true label with the class label of the node as the target, so that nodes of the same class are closer in the vector space. The formula is: , where C represents the number of node classes; N represents the number of nodes y i c represents the i -th component of the true label of the c -th node; p ic The component of the label predicted by the model c ; L cls Indicates the cross-entropy loss of all node classifications.

[0055] In order to retain the graph structure information and make the current node and neighbor nodes closer in the vector space, the second loss function of GAT is the cosine similarity loss between the current node and neighbor nodes. The formula is as follows: , where cosin_similarity(h i ,h j ) Indicates the cosine similarity of the embedding representations of calculating node i and node j , where j is i one of the neighbor nodes of

[0056] Thus, the total objective loss function of GAT can be expressed as: L = l cls + L consin .

[0057] S6. Fault diagnosis: The user inputs a problem description, uses the entity extraction SpERT model to complete entity extraction; and obtains the category labels to which each entity belongs, performs graph retrieval based on each entity, and completes knowledge graph retrieval matching and vector matching based on GAT.

[0058] If the nodes extracted through entity extraction cannot match the existing nodes when retrieving the fault graph, vector initialization (fixed dimension) is performed based on the information such as the name and attributes of the node. At the same time, based on the trained GAT network, the vector representation of the node to be queried is vector-matched with the nodes of the same category in GAT. The graph nodes with vector similarity exceeding the threshold are used as candidate nodes to construct a candidate set, and the "fault phenomenon" and "fault cause" nodes associated with them are queried. The scores are calculated according to the number of occurrences, and the query diagnosis results are returned from high to low.

[0059] For example, referring to Figure 3 , the user input is: "What faults may occur when the load-bearing strut leaks oil? What is the reason?" Through the trained SpERT model, entity extraction can be completed, and entity nodes 1 - "load-bearing strut (component)" and entity node 2 - "oil leakage (symptom)" can be extracted. Based on these nodes, knowledge graph retrieval matching and vector matching based on GAT can be completed.

[0060] Diagnostic steps: (1) Retrieve whether Entity 1 and Entity 2 exist in the fault knowledge graph. If they exist, find the associated fault description nodes, and find the fault description with the highest score from the union set and the associated fault causes; (2) If Entity Node 1 or Entity Node 2 does not exist in the fault knowledge graph, after the GAT network training is completed, calculate the similarity between the obtained node embedding representation and the user question query node. When the similarity between the node to be queried and the node representation in the GAT exceeds the threshold of 0.8, put this node into the candidate set. After the matching is completed, query the fault description nodes associated with the nodes in the candidate set, score each fault description node according to the number of occurrences, and return the query diagnosis result from high to low according to the scores.

[0061] The above are only the preferred embodiments of the present invention, and do not impose any form of limitation on the present invention. Any simple modification or equivalent change made to the above embodiments based on the technical essence of the present invention shall fall within the protection scope of the present invention.

Claims

1. A method for constructing a landing gear failure system based on graph neural network and knowledge graph, characterized in that: The steps include: S1. Data collection: Collect relevant historical data of landing gear failures and integrate various historical failure data as the data source for constructing the landing gear failure knowledge graph; S2, data preprocessing: preprocessing the data source in step S1, including formatting the data source and extracting information; S3. Training entity-relationship extraction model: Use the neural network-based entity-relationship extraction model SpERT to automatically extract graph nodes and obtain RDF triple data of entity-relationship-entity; S4, constructing a knowledge graph: according to steps S2 and S4, the constructed node and relationship knowledge is stored in the Neo4j graph database, and a knowledge graph based on the landing gear fault data is constructed; S5. Training the GAT network: The GAT network is used as the basic model for training to obtain node features. The GAT model input includes the feature matrix of all nodes and the adjacency matrix of the knowledge graph. The optimization objectives of the GAT model include classification cross entropy and minimizing the cosine similarity between the current node and all its neighboring nodes to obtain the optimized GAT network model.

2. The method for constructing a landing gear fault system based on graph neural network and knowledge graph according to claim 1 is characterized in that: In step S1, the relevant historical data includes fault data including maintenance manuals and inspection records, and the fault data includes fault time, fault component, component symptoms, fault description and fault cause. Among them: the faulty parts include shock absorbers, load struts, and retraction and extension mechanisms; component symptoms include vibration and oil leakage.

3. The method for constructing a landing gear fault system based on graph neural network and knowledge graph according to claim 1 is characterized in that: In step S2, the formatting method is: converting the file with different fonts and encoding into a text file with a unified encoding format; The information extraction method is: extracting fault knowledge from original historical files in different formats.

4. The method for constructing a landing gear fault system based on graph neural network and knowledge graph according to claim 2 is characterized in that: In step S3, when training the entity-relationship extraction model, an artificial entity-relationship data set is first constructed to divide the original fault data into multiple categories of entities, including: fault components, component symptoms, fault descriptions, and fault causes; The relationship representation includes: faulty component—(occurrence)—component symptom, faulty component—(cause)—fault description, fault cause—(cause)—fault description.

5. The method for constructing a landing gear fault system based on graph neural network and knowledge graph according to claim 4 is characterized in that: In step S4, the specific method for constructing a knowledge graph based on landing gear fault data is as follows: S4.

1. Store the constructed node and relationship knowledge in the Neo4j graph database; S4.

2. Manage nodes and relationship edges through Cypher declarative query language; S4.

3. Neo4j provides visualization tools to visually check the construction effect of the knowledge graph; S4.4, the interface between Neo4j and TensorFlow deep learning framework provides technical support for subsequent graph representation learning; S4.

5. Based on the Neo4j graph database, a knowledge graph based on landing gear failure data is constructed.

6. The method for constructing a landing gear fault system based on graph neural network and knowledge graph according to claim 5 is characterized in that: In step S5, the method of using the GAT network as a basic model to train and obtain node features is: S5.1.

1. When updating node representation, GAT can incorporate network structure information. The first-order neighbor nodes of node i are the main participants in updating the current node representation. The attention coefficient satisfies the following relationship (1): （1）， in, W represents a shared parameter matrix, which is used to map the feature representations of nodes; h i and h j Respectively represent nodes i and nodes j Features, The symbol || represents the splicing operation, that is, the node i and nodes j The feature representations are concatenated; a(.) represents a mapping operation, which maps the concatenated vector to a real number. N i Representation Node i The set of neighbor nodes; S5.1.

2. After the attention coefficient is calculated, it is normalized to satisfy the following relationship (2): （2）， in, LeakReLU Represents a nonlinear activation function Relu A variant of α ij It represents the weight coefficient after normalization; The entire formula corresponds to the deep learning softmax function; S5.1.

3. Node i The attention coefficient vector corresponding to the neighbor node of the node and the feature matrix of the neighbor node are weighted summed to obtain the node i The updated feature representation satisfies the following relationship (3): （3）， in h i ´ Represents the nodes after weighted summation i Feature representation (integrating neighborhood node information); σ(.) represents the activation function.

7. The method for constructing a landing gear fault system based on graph neural network and knowledge graph according to claim 6 is characterized in that: Multi-head graph attention is used to obtain node representations from multiple angles, satisfying the following relationship (4): （4）， Among them, K represents the number of heads of multi-head graph attention; | | indicates a splicing operation; a(.) represents the mapping function, which concatenates the node representations obtained by multiple single-head graph attentions, and then maps them back to the original dimension size through a mapping layer (linear layer), thereby obtaining the node feature representation of multi-head attention that integrates multiple angles.

8. The method for constructing a landing gear fault system based on graph neural network and knowledge graph according to claim 6, characterized in that: In step S5, the method of optimizing the target of the GAT model is: S5.2.

1. The first loss when training the GAT network is node classification, which takes the node category label as the goal to minimize the gap between the predicted label and the true label, so that nodes of the same type are closer in the vector space to satisfy the relationship (5): （5）； in, C Indicates the number of categories of nodes; N Indicates the number of nodes; y i c Indicates i The true label of the node c Quantity; p i c Represents the label predicted by the model c Quantity; L cls represents the cross entropy loss of all node classifications; S5.2.2, the second loss function of GAT is the cosine similarity loss between the current node and the neighboring nodes, which satisfies the relationship (6): （6）， in cosin_similarity(h i ,h j ) Represents a compute node i and nodes j The cosine similarity of the embedding representation of j yes i One of the neighbor nodes of S5.2.

3. The total objective loss function of GAT is: L = l cls + L consin .

9. A landing gear fault system based on a graph neural network and a knowledge graph obtained by the construction method as described in any one of claims 1 to 8.

10. Application of the landing gear fault system as claimed in claim 9 in landing gear fault diagnosis.

11. The use according to claim 10, characterized in that: The steps include: ①. According to the user input information, the trained SpERT model is used to complete entity extraction and obtain entity nodes; ②. Based on the entity nodes of step ①, combined with the knowledge graph based on landing gear fault data constructed in step S4, complete the knowledge graph retrieval matching and GAT-based vector matching to obtain the diagnosis result.

12. The landing gear failure system based on graph neural network and knowledge graph according to claim 11, characterized in that: In step ②, check whether the entity node exists in the fault knowledge graph. Ⅰ. If it exists, determine the fault description node associated with it, and determine the fault description with the highest score and the fault cause associated with it from the union; Ⅱ. If it does not exist, the node embedding representation obtained after the GAT network training is completed will be used to calculate the similarity with the user's question query node. When the similarity between the node to be queried and the node representation in GAT exceeds the threshold, the node will be placed in the candidate set. After the matching is completed, the fault description node associated with the node in the candidate set will be queried, and each fault description node will be scored according to the number of occurrences. The query diagnosis result will be returned from high to low according to the score.

13. The landing gear failure system based on graph neural network and knowledge graph according to claim 12, characterized in that: The threshold is 0.8.

Images