A fault scenario search method, system, device, storage medium and product

Abstract

This invention discloses a method, system, device, storage medium, and product for searching fault solutions. It involves using a search engine to perform preliminary matching of fault descriptions to obtain a set of candidate fault solutions; extracting semantic vectors from both the fault descriptions and candidate fault solutions; constructing a syntactic dependency tree for the fault descriptions and candidate fault solutions to obtain a graph structure; inputting the graph structure and the corresponding semantic vectors into a graph convolutional neural network to obtain syntactic feature vectors for the fault descriptions and the candidate fault solutions; bidirectionally fusing and concatenating the syntactic feature vectors to obtain a fused feature for each candidate fault solution; and ranking the candidate fault solutions based on the fused features to obtain an ordered fault solution matching the fault description. This invention enables deep capture of semantic and syntactic structures to improve search relevance and provide more accurate results for fault solution searching.

Description

Technical Field

[0001] This invention relates to the field of search engine improvement technology, and in particular to a method, system, device, storage medium, and product for troubleshooting. Background Technology

[0002] In the daily training and tuning of large models, effective fault knowledge management and search can significantly save tuning personnel time and improve their fault resolution efficiency.

[0003] Traditional search engine technologies, such as Elasticsearch, often face the problem of low relevance of search results when performing fast document content searches, and their performance is limited when handling complex semantics or long queries. Summary of the Invention

[0004] The embodiments of the present invention aim to provide a method, system, device, storage medium and product for searching fault solutions, which can deeply capture semantic and syntactic structures to improve search relevance and provide more accurate results for fault solution searching.

[0005] In a first aspect, embodiments of the present invention provide a method for searching fault solutions, comprising: Based on the search engine, the fault descriptions are initially matched to obtain a set of candidate fault solutions; Deep semantic representations of the fault description and the candidate fault scheme are extracted respectively to obtain semantic vectors of the fault description and the candidate fault scheme. Construct syntactic dependency trees for fault description and candidate fault solutions respectively, and convert each syntactic dependency tree into a graph structure; The graph structure and the corresponding semantic vector are input into a graph convolutional neural network to obtain the first syntactic feature vector of the fault description and the second syntactic feature vector of the candidate fault scheme. The first syntactic feature vector and the second syntactic feature vector are bidirectionally fused and concatenated to obtain the fused features of each candidate fault scheme; Based on the fusion features, the candidate fault schemes are sorted to obtain an ordered fault scheme that matches the fault description.

[0006] As an improvement to the above scheme, the step of extracting deep semantic representations of the fault description and the candidate fault scheme respectively to obtain semantic vectors for the fault description and the candidate fault scheme includes: The fault description is converted into a first word vector sequence using word embedding technology, and each of the candidate fault schemes is converted into a second word vector sequence. By using a bidirectional long short-term memory network, the first word vector sequence and the second word vector sequence are encoded respectively to obtain the hidden state vectors of the fault description and the candidate fault scheme, which serve as semantic vectors.

[0007] As an improvement to the above scheme, the step of constructing syntactic dependency trees for fault description and candidate fault schemes respectively, and converting the syntactic dependency trees one by one into a graph structure, includes: Using a dependency parser, syntactic dependency parsing is performed on the fault description and candidate fault solutions respectively, resulting in syntactic dependency trees for the fault description and candidate fault solutions. For each grammatical dependency tree, construct an adjacency matrix with self-loops based on the node itself and the dependency relationships between nodes to obtain the graph structure.

[0008] As an improvement to the above scheme, after performing syntactic dependency analysis on the fault description and candidate fault solutions using a dependency parser to obtain their respective syntactic dependency trees, the fault solution search method further includes: A soft pruning strategy based on a self-attention mechanism is adopted to assign weights to the edges of the syntactic dependency tree, and the syntactic dependency tree is updated according to the weights.

[0009] As an improvement to the above scheme, the step of inputting the graph structure and the corresponding semantic vector into a graph convolutional neural network to obtain the first syntactic feature vector of the fault description and the second syntactic feature vector of the candidate fault scheme includes: The first graph structure of the fault description and the corresponding semantic vector are input into a pre-trained graph convolutional neural network. The graph convolutional neural network performs feature aggregation on the neighbor nodes in the first graph structure to obtain the first syntactic feature vector of the fault description. The second graph structure and corresponding semantic vector of the candidate fault scheme are input into a pre-trained graph convolutional neural network. The graph convolutional neural network performs feature aggregation on the neighbor nodes in the second graph structure to obtain the second syntactic feature vector of the candidate fault scheme.

[0010] As an improvement to the above scheme, the step of bidirectionally fusing and concatenating the first syntactic feature vector and the second syntactic feature vector to obtain the fused features of each candidate fault scheme includes: Calculate the average value of the first syntactic feature vector to obtain the first average vector of the fault description; The first average vector is used to encode the second syntactic feature vector to obtain the first interactive attention weight; Based on the first interactive attention weight, information is extracted from the second syntactic feature vector of the candidate fault scheme to obtain a candidate fault scheme representation that incorporates the fault description. Calculate the average value of the second syntactic feature vector to obtain the second average vector of the candidate fault scheme; The second average vector is used to encode the first syntactic feature vector to obtain the second interactive attention weight; Based on the second interactive attention weight, information is extracted from the first syntactic feature vector of the fault description to obtain a fault description representation that incorporates candidate fault schemes; The candidate fault scheme representation and the fault description representation are concatenated to obtain the fusion feature of the corresponding candidate fault scheme.

[0011] Secondly, embodiments of the present invention provide a fault solution search system, comprising: The preliminary matching module is used to perform preliminary matching of fault descriptions based on the search engine to obtain a set of candidate fault solutions; The semantic extraction module is used to extract the deep semantic representations of the fault description and the candidate fault scheme respectively, so as to obtain the semantic vectors of the fault description and the candidate fault scheme respectively. The graph construction module is used to construct syntactic dependency trees for fault description and candidate fault solutions respectively, and convert the syntactic dependency trees into graph structures one by one. The syntactic feature extraction module is used to input the graph structure and the corresponding semantic vector into the graph convolutional neural network to obtain the first syntactic feature vector of the fault description and the second syntactic feature vector of the candidate fault scheme; The feature fusion module is used to bidirectionally fuse and concatenate the first syntactic feature vector and the second syntactic feature vector to obtain the fused features of each candidate fault scheme; The scheme ranking module is used to rank the candidate fault schemes according to the fusion features to obtain an ordered fault scheme that matches the fault description.

[0012] Thirdly, embodiments of the present invention provide a fault solution search device, including a processor, a memory, and a computer program stored in the memory and configured to be executed by the processor, wherein the processor executes the computer program to implement the fault solution search method described above.

[0013] Fourthly, embodiments of the present invention provide a computer-readable storage medium comprising a stored computer program, wherein, when the computer program is executed, it controls the device where the computer-readable storage medium is located to perform the fault search method described above.

[0014] Fifthly, embodiments of the present invention provide a computer program product, the computer program product including a computer program or computer instructions, wherein when the computer program or computer instructions are executed by a processor, the fault search method described above is performed.

[0015] Compared with existing technologies, this invention discloses a method, system, device, storage medium, and product for searching fault solutions. It first performs preliminary matching of fault descriptions based on a search engine to obtain a set of candidate fault solutions. Then, it extracts deep semantic representations of both the fault descriptions and the candidate fault solutions to obtain semantic vectors for each. Next, it constructs syntactic dependency trees for both the fault descriptions and the candidate fault solutions, converting each tree into a graph structure. Finally, it inputs the graph structures and corresponding semantic vectors into a graph convolutional neural network to obtain a first syntactic feature vector for the fault description and a second syntactic feature vector for the candidate fault solution. The first and second syntactic feature vectors are then bidirectionally fused and concatenated to obtain a fused feature for each candidate fault solution. Based on the fused feature, the candidate fault solutions are sorted to obtain an ordered fault solution matching the fault description. Using this invention, semantic and syntactic structures can be deeply captured to improve search relevance and provide more accurate results for fault solution searching. Attached Figure Description

[0016] Figure 1 This is a flowchart illustrating the steps of a fault search method provided in an embodiment of the present invention; Figure 2 This is a schematic diagram of a syntactic dependency tree constructed based on fault description provided in an embodiment of the present invention; Figure 3 This is a schematic diagram of a syntactic dependency tree constructed based on candidate fault schemes, provided in an embodiment of the present invention; Figure 4 This is a schematic diagram of the structure of a fault search system provided in an embodiment of the present invention; Figure 5 This is a schematic diagram of the structure of a fault search device provided in an embodiment of the present invention. Detailed Implementation

[0017] The technical solutions of the embodiments 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.

[0018] In the description and claims, it should be understood that the terms "first," "second," etc., used in the description and claims are only for the purpose of distinguishing the description of the same technical features, and should not be construed as indicating or implying relative importance or implicitly specifying the number of technical features indicated, nor necessarily the order of description or chronological order. The terms are interchangeable where appropriate. Therefore, a feature defined as "first" or "second" may explicitly or implicitly include at least one of that feature.

[0019] Traditional Elasticsearch search engines typically employ TF-IDF (Term Frequency-Inverse Document Frequency) algorithms, such as the BM25 (Best Matching 25) algorithm, which rely on term frequency and inverse document frequency in the text for scoring. However, traditional search engines struggle to capture deep semantic relationships within text and perform poorly when handling complex semantics or long queries.

[0020] In the era of artificial intelligence, deep learning has been widely applied in many fields, and some technologies have also applied deep learning networks to fault search. However, the fault matching models based on CNNs (Convolutional Neural Networks) currently proposed have certain limitations.

[0021] Fault matching models based on CNNs extract local features through convolutional kernels, which can effectively capture local information. However, when processing long texts, they tend to ignore global contextual information, resulting in poor performance in capturing overall semantics.

[0022] Based on the above considerations, embodiments of the present invention provide a method for searching fault solutions. Please refer to [link to relevant documentation]. Figure 1 In this embodiment, the fault search method is specifically executed through steps S1 to S6: S1. Based on the search engine, perform preliminary matching of fault descriptions to obtain a set of candidate fault solutions; S2. Extract the deep semantic representations of the fault description and the candidate fault scheme respectively to obtain the semantic vectors of the fault description and the candidate fault scheme respectively; S3. Construct syntactic dependency trees for fault description and candidate fault solutions respectively, and convert the syntactic dependency trees into graph structures one by one; S4. Input the graph structure and the corresponding semantic vector into the graph convolutional neural network to obtain the first syntactic feature vector of the fault description and the second syntactic feature vector of the candidate fault scheme; S5. The first syntactic feature vector and the second syntactic feature vector are bidirectionally fused and concatenated to obtain the fused features of each candidate fault scheme; S6. Based on the fusion features, sort the candidate fault schemes to obtain an ordered fault scheme that matches the fault description.

[0023] It should be noted that, in this embodiment of the invention, there is a preset knowledge base, which includes fault solutions for resolving several faults, and each fault solution corresponds to a standard fault description text. The role of the search engine is to match the fault descriptions input by the user or recognized by the system with the fault solutions in the knowledge base, so as to filter out several candidate fault solutions that are relevant to the fault descriptions from a massive number of fault solutions.

[0024] In some preferred embodiments, the ES search engine is used for initial matching of fault descriptions. The ES search engine can store structured, unstructured, and vector data in real time and provides fast mixed and vector search.

[0025] In this embodiment of the invention, a search engine can be used to quickly filter out candidate failure schemes from a large number of failure scenarios, significantly reducing the subsequent computational burden. However, it should also be noted that, due to the technical limitations of traditional search engines, they struggle to accurately capture deep semantic relationships in text; therefore, the matching operation performed by the search engine is only coarse-grained.

[0026] Furthermore, by performing multi-dimensional semantic and syntactic analysis on fault descriptions and candidate fault solutions, this embodiment of the invention provides a more refined matching and ranking of each candidate fault solution selected by the search engine, which can effectively improve the relevance between fault solutions and fault descriptions and optimize the accuracy of search results.

[0027] Both the fault description and candidate fault solutions are in text format, and deep semantic representations of these descriptions and solutions can be extracted using NLP (Natural Language Processing) techniques. For example, tools such as semantic combination based on word vectors, contextual semantic encoding based on sequence modeling, global semantic modeling based on Transformer, or structured semantic fusion based on knowledge graphs can be used. The specific semantic vector extraction tools selected and combined are determined by actual business needs.

[0028] Syntactic analysis is one of the key technologies in natural language processing, which analyzes input text sentences to obtain their syntactic structure. Syntactic dependency parsing is a type of syntactic analysis task that identifies the interdependencies between words in a sentence.

[0029] In dependency grammar theory, a subordinate relationship exists between words. If one word modifies another, the modifier is called the subordinate word, and the modified word is called the governing word. The grammatical relationship between them is called a dependency relationship. By pointing arrows from the governing word to the subordinate word, all word dependency relationships in the text can be represented as directed edges, and the resulting structure is called a syntactic dependency tree.

[0030] For example, in one specific embodiment, the fault description is "GPU carrier power-on failure," which can be segmented into "GPU," "carrier," "power-on," and "failure." Based on the dependencies between these words, a structure such as... Figure 2 The syntactic dependency tree shown.

[0031] In another specific embodiment, a candidate fault solution is "check whether the component and its slot are damaged". Through syntactic dependency analysis, a solution such as... can be constructed. Figure 3 The syntactic dependency tree shown.

[0032] Understandably, syntactic dependency trees have definitions of nodes, edges, and edge weights, and therefore can be naturally converted into graph structures. In this embodiment of the invention, constructing a syntactic dependency tree and converting it into a graph structure can define input data that is easy to process for graph convolutional neural networks (GCNs), so as to deeply mine the semantic and syntactic structures of fault descriptions and candidate fault solutions through graph convolutional neural networks and obtain syntactic feature vectors.

[0033] The first syntactic feature vector performs deep semantic analysis on the fault description text, fusing syntactic structures. The second syntactic feature vector performs deep semantic analysis on the candidate fault solution text, fusing syntactic structures. In this embodiment of the invention, by bidirectionally fusing and concatenating the first and second syntactic feature vectors, the representations of the fault description and the candidate fault solutions can be mutually fused to obtain fused features. These fused features can reflect the degree of matching between the fault description and the candidate fault solutions, effectively improving the matching evaluation dimension of the candidate fault solutions.

[0034] In some preferred embodiments, when ranking candidate fault solutions based on fusion features, the candidate fault solutions are further filtered, and only the top n ordered fault solutions are displayed. Here, n is an integer value customized based on user requirements.

[0035] In the above scheme, by performing deep feature extraction and feature fusion on fault descriptions and candidate fault solutions based on semantic and syntactic structures, the relevance of the search can be improved, providing more accurate results for fault solution search.

[0036] As a preferred implementation, step S2 involves extracting deep semantic representations of the fault description and the candidate fault solutions to obtain semantic vectors for each, including: The fault description is converted into a first word vector sequence using word embedding technology, and each of the candidate fault schemes is converted into a second word vector sequence. By using a bidirectional long short-term memory network, the first word vector sequence and the second word vector sequence are encoded respectively to obtain the hidden state vectors of the fault description and the candidate fault scheme, which serve as semantic vectors.

[0037] In some preferred embodiments, the text description is converted into a sequence of word vectors using a pre-trained 300-dimensional GloVe (Global Vectors for Word Representation) model. GloVe uses an embedding matrix to store the trained word vectors, and the embedding matrix is ​​represented as follows: ;in, This indicates the size of the word sequence, which is the number of words in the sentence. The dimension of the word embedding.

[0038] For example, the first word vector sequence obtained from the fault description transformation is represented as follows: The second word vector sequence obtained by transforming the candidate fault scheme is represented as: The vector of each word in the sentence. Corresponding embedding matrix elements in .

[0039] Compared to traditional recurrent neural networks (RNNs), bidirectional long short-term memory (Bi-LSTM) networks are better at capturing long-term dependencies and avoid the vanishing and exploding gradient problems, making them suitable for processing long sequence data. Furthermore, Bi-LSTM can process time-series data simultaneously from front to back and from back to front, enabling it to capture more comprehensive contextual information within the data.

[0040] Therefore, in this embodiment of the invention, the sequential semantic features of the text are learned through a Bi-directional Long Short-Term Memory (Bi-LSTM) network. The Bi-LSTM is used to encode the first word vector sequence of the fault description and the second word vector sequence of the candidate fault schemes, respectively, to obtain the first hidden state vector of the fault description, i.e., the first semantic vector, and the hidden state vector of the candidate fault schemes, i.e., the second semantic vector.

[0041] For example, the first semantic vector is represented as The second semantic vector is represented as ,in and These represent the sources from Bi-LSTM. The hidden state vector at time step 1. It is the dimension of the hidden state vector output by the unidirectional LSTM.

[0042] The above scheme combines word embedding technology with bidirectional long short-term memory networks, which can efficiently learn the semantic features of fault descriptions and candidate fault solutions, thereby capturing more complex semantic information in the text.

[0043] As a preferred implementation, step S3 involves constructing syntactic dependency trees for fault descriptions and candidate fault solutions, and converting each syntactic dependency tree into a graph structure, as executed in steps S31-S32. S31. Using a dependency parser, perform syntactic dependency analysis on the fault description and candidate fault solutions respectively to obtain the syntactic dependency trees of the fault description and candidate fault solutions. S32. For each syntactic dependency tree, construct an adjacency matrix with self-loops based on the node itself and the dependency relationships between nodes to obtain the graph structure.

[0044] In this embodiment of the invention, multiple discontinuous words in a text are grouped into a smaller range by using dependency relations, and further features can be gathered by convolution to handle the case where keywords are described by discontinuous words.

[0045] In some preferred embodiments, Stanford Parser is used for fault description and syntactic dependency analysis of candidate fault schemes. Stanford Parser is a natural language processing tool for syntactic dependency analysis, which can perform word segmentation, part-of-speech analysis, and dependency relation analysis on text, and can directly output a syntactic dependency tree.

[0046] When converting a syntactic dependency tree into a graph structure, the nodes of the syntactic dependency tree can be directly converted into nodes of the graph, and the dependency relations of the syntactic dependency tree can be converted into edges of the graph. It should be noted that in this embodiment of the invention, the direction of the dependency relations does not need to be considered during the construction of the graph structure.

[0047] For example, for Figure 2 The syntactic dependency tree shown can be converted into a graph with 4 nodes. Therefore, the graph structure can be represented by a 4×4 adjacency matrix A. If the nodes... and If there is a dependency relationship between them, then and .

[0048] Considering that a node in a syntactic dependency tree will not connect to itself, at this time The information in will not be carried over Therefore, in this embodiment of the invention, a self-loop is added to each node, and the graph structure is an adjacency matrix with self-loops.

[0049] based on Figure 2 The graph structure constructed from the syntactic dependency tree can be represented as: .

[0050] In the above scheme, the distance between non-adjacent words can be significantly reduced by using a dependency parser; and the adjacency matrix with self-loops can prevent the loss of some node information during convolution.

[0051] Further, preferably, after performing step S31, using a dependency parser to perform syntactic dependency analysis on the fault description and candidate fault solutions respectively, and obtaining their respective syntactic dependency trees, the fault solution search method further includes: A soft pruning strategy based on a self-attention mechanism is adopted to assign weights to the edges of the syntactic dependency tree, and the syntactic dependency tree is updated according to the weights.

[0052] Practice has shown that in the application of binarized adjacency matrices, due to the large variation in node degree, directly applying the binarized adjacency matrix may cause significant fluctuations in nodes during graph convolution operations. This can lead to sentence expressions that tend to favor nodes with high degree while ignoring the information carried by other nodes, resulting in deviations in sentence expression.

[0053] Syntactic dependency relations can represent not only the association between two words, but also the syntactic relationship between them. Each syntactic relation has a different impact on the final prediction result, so simply setting all relations to 1 will obviously lose some syntactic information.

[0054] Therefore, in a preferred embodiment of the present invention, a soft pruning strategy based on self-attention (SA) is proposed to address this situation. This strategy assigns weights to each edge in the dependency tree, thereby transforming the original dependency tree into an edge-weighted graph. A higher weight indicates a stronger correlation between two nodes.

[0055] In some preferred embodiments, the syntactic dependency tree is updated using the following self-attention calculation formula: ; in, , and Both are the output representations of the previous layer in GCN; , and This represents the pre-trained weight matrix.

[0056] For example, the updated syntactic dependency tree is represented as follows: .

[0057] The core idea of ​​soft pruning in syntactic dependency trees is to learn the relationships between nodes through a self-attention mechanism and assign appropriate weights to them to aggregate effective information in the dependency tree. In contrast, rule-based hard pruning strategies have drawbacks in practice, as they can easily lead to the loss of key information, thereby reducing the model's performance.

[0058] In the above scheme, a self-attention mechanism is used to perform soft pruning on the syntactic dependency tree. While maintaining the integrity of the text structure, weights are assigned to each edge in the dependency tree, which can utilize the effective information in the dependency tree and suppress noise. This method further improves the robustness and accuracy of the model by refining the syntactic structure of the text.

[0059] In a preferred embodiment, step S4, inputting the graph structure and the corresponding semantic vector into a graph convolutional neural network to obtain the first syntactic feature vector of the fault description and the second syntactic feature vector of the candidate fault scheme, includes: The first graph structure of the fault description and the corresponding semantic vector are input into a pre-trained graph convolutional neural network. The graph convolutional neural network performs feature aggregation on the neighbor nodes in the first graph structure to obtain the first syntactic feature vector of the fault description. The second graph structure and corresponding semantic vector of the candidate fault scheme are input into a pre-trained graph convolutional neural network. The graph convolutional neural network performs feature aggregation on the neighbor nodes in the second graph structure to obtain the second syntactic feature vector of the candidate fault scheme.

[0060] In order to extract useful information from the syntactic dependency tree, in some preferred embodiments, an updated syntactic dependency tree is used to optimize the GCN’s ability to extract features.

[0061] It should be noted that the adjacency matrices described in the following embodiments are all adjacency matrices with self-loops constructed based on the updated syntactic dependency tree. In some embodiments, if the syntactic dependency tree is not updated based on a self-attention mechanism, a binarized syntactic dependency tree can also be used directly.

[0062] In a graph convolutional neural network, the input to the first layer of the GCN is the hidden state of the fault scheme. The node information update is represented as: ; in, For activation functions; This is an adjacency matrix with self-loops constructed based on the updated syntactic dependency tree; This is the weight matrix; The normalization constant is Indicates the first The degree of each node; This indicates the bias term.

[0063] The first syntactic feature vector of the fault description output by the L-th layer graph convolutional neural network is represented as follows: , The second syntactic feature vector of the candidate fault scheme output by the Lth layer graph convolutional neural network is represented as follows: , .

[0064] In the above scheme, graph convolutional neural networks can integrate global and local structural information of text, thereby enabling more accurate fault matching.

[0065] As a preferred implementation, step S5 involves bidirectionally fusing and concatenating the first syntactic feature vector and the second syntactic feature vector to obtain the fused features of each candidate fault scheme, including: Calculate the average value of the first syntactic feature vector to obtain the first average vector of the fault description; The first average vector is used to encode the second syntactic feature vector to obtain the first interactive attention weight; Based on the first interactive attention weight, information is extracted from the second syntactic feature vector of the candidate fault scheme to obtain a candidate fault scheme representation that incorporates the fault description. Calculate the average value of the second syntactic feature vector to obtain the second average vector of the candidate fault scheme; The second average vector is used to encode the first syntactic feature vector to obtain the second interactive attention weight; Based on the second interactive attention weight, information is extracted from the first syntactic feature vector of the fault description to obtain a fault description representation that incorporates candidate fault schemes; The candidate fault scheme representation and the fault description representation are concatenated to obtain the fusion feature of the corresponding candidate fault scheme.

[0066] It should be noted that both the first and second syntactic feature vectors are applied to all words in a single text as a whole. For example, the first syntactic feature vector is the feature sequence of all words in the fault description. Calculating the average of the first syntactic feature vector is equivalent to calculating the average of the feature vectors of each word in a single fault description. Similarly, the second average vector can be calculated.

[0067] In some preferred embodiments, the second average vector of candidate failure schemes Represented as: ; Where n is the length of the candidate failure scheme; This is the second syntactic feature vector output by the L-layer graph convolutional neural network.

[0068] In this embodiment of the invention, interactive attention is used to enable fault descriptions and fault solutions to perceive each other, generating candidate fault solution representations incorporating fault descriptions and fault description representations incorporating candidate fault solutions, respectively. By learning interactive semantic information, features can be extracted more accurately.

[0069] In some preferred embodiments, the first interactive attention weight Represented as: ; in, For the weighted attention scoring function, This is the first average vector. For example, , Represents the weight matrix. for The transpose of .

[0070] Then, by utilizing the first interactive attention weights, the second syntactic feature vector output from the L-layer graph convolutional neural network can be selectively extracted. Extract relevant information to obtain a candidate fault scheme representation that incorporates the fault description. , 。

[0071] Similarly, in this embodiment of the invention, the second average vector of the candidate fault scheme is also utilized. The first syntactic feature vector output by the L-layer graph convolutional neural network Encode the second interactive attention weights. Furthermore, based on the second interaction attention weight, the first syntactic feature vector is used to... Information is extracted to obtain a fault description representation that incorporates candidate fault schemes. .

[0072] In this embodiment of the invention, candidate failure schemes are represented as follows: and fault description The features are then concatenated to obtain fused features, which incorporate interactive semantic information of fault description and fault solution, as well as text structure semantics and syntactic information.

[0073] In some preferred embodiments, the fused features are input to a SoftMax normalization layer to obtain the score of the failure scheme in each relevant category, and then the candidate failure schemes are ranked.

[0074] For example, the normalized representation of the fusion features is as follows: ; in, This is the weight matrix of the SoftMax normalized layer. This is a bias term.

[0075] The above scheme further enhances the close interaction between fault description and fault solution through interactive attention mechanism, which can generate richer and more accurate feature representations, thereby significantly improving the relevance of fault solution recommendation and demonstrating superior performance in practical applications.

[0076] The fault solution search method provided in this embodiment of the invention improves the relevance of the search by performing deep feature extraction and feature fusion on fault descriptions and candidate fault solutions based on semantic and syntactic structure, and provides more accurate results for fault solution search.

[0077] This invention provides a fault search system. Please refer to [link to relevant documentation]. Figure 4 The fault solution search system includes a preliminary matching module 11, a semantic extraction module 12, a graph construction module 13, a syntactic feature extraction module 14, a feature fusion module 15, and a solution ranking module 16, wherein: The preliminary matching module 11 is used to perform preliminary matching of fault descriptions based on a search engine to obtain a set of candidate fault solutions; The semantic extraction module 12 is used to extract the deep semantic representations of the fault description and the candidate fault scheme respectively, so as to obtain the semantic vectors of the fault description and the candidate fault scheme respectively. Graph construction module 13 is used to construct syntactic dependency trees for fault description and candidate fault scheme respectively, and convert the syntactic dependency trees into graph structures one by one; Syntactic feature extraction module 14 is used to input the graph structure and the corresponding semantic vector into the graph convolutional neural network to obtain the first syntactic feature vector of the fault description and the second syntactic feature vector of the candidate fault scheme; The feature fusion module 15 is used to bidirectionally fuse and concatenate the first syntactic feature vector and the second syntactic feature vector to obtain the fused features of each candidate fault scheme; The scheme sorting module 16 is used to sort the candidate fault schemes according to the fusion features to obtain an ordered fault scheme that matches the fault description.

[0078] In a preferred embodiment, the semantic extraction module 12 is specifically used for: The fault description is converted into a first word vector sequence using word embedding technology, and each of the candidate fault schemes is converted into a second word vector sequence. By using a bidirectional long short-term memory network, the first word vector sequence and the second word vector sequence are encoded respectively to obtain the hidden state vectors of the fault description and the candidate fault scheme, which serve as semantic vectors.

[0079] In a preferred embodiment, the graph construction module 13 is specifically used for: Using a dependency parser, syntactic dependency parsing is performed on the fault description and candidate fault solutions respectively, resulting in syntactic dependency trees for the fault description and candidate fault solutions. For each grammatical dependency tree, construct an adjacency matrix with self-loops based on the node itself and the dependency relationships between nodes to obtain the graph structure.

[0080] Further, preferably, after the graph construction module 13 completes the syntactic dependency analysis of the fault description and candidate fault schemes through the dependency analyzer to obtain their respective syntactic dependency trees, it is also used for: A soft pruning strategy based on a self-attention mechanism is adopted to assign weights to the edges of the syntactic dependency tree, and the syntactic dependency tree is updated according to the weights.

[0081] In a preferred embodiment, the syntactic feature extraction module 14 is specifically used for: The first graph structure of the fault description and the corresponding semantic vector are input into a pre-trained graph convolutional neural network. The graph convolutional neural network performs feature aggregation on the neighbor nodes in the first graph structure to obtain the first syntactic feature vector of the fault description. The second graph structure and corresponding semantic vector of the candidate fault scheme are input into a pre-trained graph convolutional neural network. The graph convolutional neural network performs feature aggregation on the neighbor nodes in the second graph structure to obtain the second syntactic feature vector of the candidate fault scheme.

[0082] In a preferred embodiment, the feature fusion module 15 is specifically used for: Calculate the average value of the first syntactic feature vector to obtain the first average vector of the fault description; The first average vector is used to encode the second syntactic feature vector to obtain the first interactive attention weight; Based on the first interactive attention weight, information is extracted from the second syntactic feature vector of the candidate fault scheme to obtain a candidate fault scheme representation that incorporates the fault description. Calculate the average value of the second syntactic feature vector to obtain the second average vector of the candidate fault scheme; The second average vector is used to encode the first syntactic feature vector to obtain the second interactive attention weight; Based on the second interactive attention weight, information is extracted from the first syntactic feature vector of the fault description to obtain a fault description representation that incorporates candidate fault schemes; The candidate fault scheme representation and the fault description representation are concatenated to obtain the fusion feature of the corresponding candidate fault scheme.

[0083] The fault solution search system provided by the embodiments of the present invention can improve the relevance of the search and provide more accurate results for fault solution search by performing deep feature extraction and feature fusion based on semantic and syntactic structure of fault description and candidate fault solutions.

[0084] Please see Figure 5 , Figure 5 This is a structural block diagram of a fault search device provided in an embodiment of the present invention. The fault search device includes a processor 31, a memory 32, and a computer program stored in the memory 32 and executable on the processor 31. When the processor 31 executes the computer program, it implements the steps in the above-described fault search method embodiments, such as steps S1 to S6.

[0085] For example, the computer program may be divided into one or more modules / units, which are stored in the memory 32 and executed by the processor 31 to complete the present invention. The one or more modules / units may be a series of computer program instruction segments capable of performing specific functions, which describe the execution process of the computer program in the fault diagnosis device.

[0086] The fault search device may include, but is not limited to, processor 31 and memory 32. Those skilled in the art will understand that the schematic diagram is merely an example of a fault search device and does not constitute a limitation on the fault search device. It may include more or fewer components than illustrated, or combine certain components, or different components. For example, the fault search device may also include input / output devices, network access devices, buses, etc.

[0087] The processor 31 can be a Central Processing Unit (CPU), or other general-purpose processors, digital signal processors (DSPs), application-specific integrated circuits (ASICs), field-programmable gate arrays (FPGAs), or other programmable logic devices, discrete gate or transistor logic devices, discrete hardware components, etc. The general-purpose processor can be a microprocessor or any conventional processor. The processor 31 is the control center of the fault detection device, connecting various parts of the fault detection device via various interfaces and lines.

[0088] The memory 32 can be used to store the computer program and / or modules. The processor 31 implements various functions of the fault search device by running or executing the computer program and / or modules stored in the memory 32 and calling the data stored in the memory 32. The memory 32 may mainly include a program storage area and a data storage area. The program storage area may store the operating system, at least one application program required for a function (such as sound playback function, image playback function, etc.), etc.; the data storage area may store data created according to the use of the mobile phone (such as audio data, phonebook, etc.). In addition, the memory 32 may include high-speed random access memory, and may also include non-volatile memory, such as hard disk, memory, plug-in hard disk, smart media card (SMC), secure digital (SD) card, flash card, at least one disk storage device, flash memory device, or other volatile solid-state storage device.

[0089] If the modules / units integrated into the fault search device are implemented as software functional units and sold or used as independent products, they can be stored in a computer-readable storage medium. Based on this understanding, all or part of the processes in the above embodiments of the present invention can also be implemented by a computer program instructing related hardware. The computer program can be stored in a computer-readable storage medium, and when executed by the processor 31, it can implement the steps of the various method embodiments described above. The computer program includes computer program code, which can be in the form of source code, object code, executable files, or certain intermediate forms. The computer-readable medium can include: any entity or device capable of carrying the computer program code, recording media, USB flash drives, portable hard drives, magnetic disks, optical disks, computer memory, read-only memory (ROM), random access memory (RAM), electrical carrier signals, telecommunication signals, and software distribution media, etc.

[0090] The above description represents the preferred embodiments of the present invention. It should be noted that those skilled in the art can make various improvements and modifications without departing from the principles of the present invention, and these improvements and modifications are also considered to be within the scope of protection of the present invention.

Claims

1. A method for searching fault solutions, characterized in that, include: Based on the search engine, the fault descriptions are initially matched to obtain a set of candidate fault solutions; Deep semantic representations of the fault description and the candidate fault scheme are extracted respectively to obtain semantic vectors of the fault description and the candidate fault scheme. Construct syntactic dependency trees for fault description and candidate fault solutions respectively, and convert each syntactic dependency tree into a graph structure; The graph structure and the corresponding semantic vector are input into a graph convolutional neural network to obtain the first syntactic feature vector of the fault description and the second syntactic feature vector of the candidate fault scheme. The first syntactic feature vector and the second syntactic feature vector are bidirectionally fused and concatenated to obtain the fused features of each candidate fault scheme; Based on the fusion features, the candidate fault schemes are sorted to obtain an ordered fault scheme that matches the fault description.

2. The fault search method as described in claim 1, characterized in that, The step of extracting deep semantic representations of the fault description and the candidate fault schemes to obtain semantic vectors for each of the fault description and the candidate fault schemes includes: The fault description is converted into a first word vector sequence using word embedding technology, and each of the candidate fault schemes is converted into a second word vector sequence. By using a bidirectional long short-term memory network, the first word vector sequence and the second word vector sequence are encoded respectively to obtain the hidden state vectors of the fault description and the candidate fault scheme, which serve as semantic vectors.

3. The fault search method as described in claim 1, characterized in that, The step of constructing syntactic dependency trees for fault descriptions and candidate fault solutions, and converting each syntactic dependency tree into a graph structure, includes: Using a dependency parser, syntactic dependency parsing is performed on the fault description and candidate fault solutions respectively, resulting in syntactic dependency trees for the fault description and candidate fault solutions. For each grammatical dependency tree, construct an adjacency matrix with self-loops based on the node itself and the dependency relationships between nodes to obtain the graph structure.

4. The fault search method as described in claim 3, characterized in that, After performing syntactic dependency analysis on the fault description and candidate fault solutions using a dependency parser to obtain their respective syntactic dependency trees, the fault solution search method further includes: A soft pruning strategy based on a self-attention mechanism is adopted to assign weights to the edges of the syntactic dependency tree, and the syntactic dependency tree is updated according to the weights.

5. The fault search method as described in claim 1, characterized in that, The step of inputting the graph structure and the corresponding semantic vector into a graph convolutional neural network to obtain the first syntactic feature vector of the fault description and the second syntactic feature vector of the candidate fault scheme includes: The first graph structure of the fault description and the corresponding semantic vector are input into a pre-trained graph convolutional neural network. The graph convolutional neural network performs feature aggregation on the neighbor nodes in the first graph structure to obtain the first syntactic feature vector of the fault description. The second graph structure and corresponding semantic vector of the candidate fault scheme are input into a pre-trained graph convolutional neural network. The graph convolutional neural network performs feature aggregation on the neighbor nodes in the second graph structure to obtain the second syntactic feature vector of the candidate fault scheme.

6. The fault search method as described in claim 1, characterized in that, The step of bidirectionally fusing and concatenating the first syntactic feature vector and the second syntactic feature vector to obtain the fused features of each candidate fault scheme includes: Calculate the average value of the first syntactic feature vector to obtain the first average vector of the fault description; The first average vector is used to encode the second syntactic feature vector to obtain the first interactive attention weight; Based on the first interactive attention weight, information is extracted from the second syntactic feature vector of the candidate fault scheme to obtain a candidate fault scheme representation that incorporates the fault description. Calculate the average value of the second syntactic feature vector to obtain the second average vector of the candidate fault scheme; The second average vector is used to encode the first syntactic feature vector to obtain the second interactive attention weight; Based on the second interactive attention weight, information is extracted from the first syntactic feature vector of the fault description to obtain a fault description representation that incorporates candidate fault schemes; The candidate fault scheme representation and the fault description representation are concatenated to obtain the fusion feature of the corresponding candidate fault scheme.

7. A fault search system, characterized in that, include: The preliminary matching module is used to perform preliminary matching of fault descriptions based on the search engine to obtain a set of candidate fault solutions; The semantic extraction module is used to extract the deep semantic representations of the fault description and the candidate fault scheme respectively, so as to obtain the semantic vectors of the fault description and the candidate fault scheme respectively. The graph construction module is used to construct syntactic dependency trees for fault description and candidate fault solutions respectively, and convert the syntactic dependency trees into graph structures one by one. The syntactic feature extraction module is used to input the graph structure and the corresponding semantic vector into the graph convolutional neural network to obtain the first syntactic feature vector of the fault description and the second syntactic feature vector of the candidate fault scheme; The feature fusion module is used to bidirectionally fuse and concatenate the first syntactic feature vector and the second syntactic feature vector to obtain the fused features of each candidate fault scheme; The scheme ranking module is used to rank the candidate fault schemes according to the fusion features to obtain an ordered fault scheme that matches the fault description.

8. A fault search device, characterized in that, It includes a processor, a memory, and a computer program stored in the memory and configured to be executed by the processor, wherein the processor, when executing the computer program, implements the fault search method as described in any one of claims 1 to 6.

9. A computer-readable storage medium, characterized in that, The computer-readable storage medium includes a stored computer program, wherein, when the computer program is executed, it controls the device on which the computer-readable storage medium is located to perform a fault search method as described in any one of claims 1 to 6.

10. A computer program product, characterized in that, The computer program product includes a computer program or computer instructions, which, when executed by a processor, perform the fault search method as described in any one of claims 1 to 6.

Images