A Clustering Method for Fault Cases in Graphical Autoencoders Based on Multi-Feature Fusion
By combining graph embedding and clustering analysis, a multi-feature fusion-based fault case clustering method for graph autoencoders is developed. This method optimizes the graph embedding and clustering process, solving the problem that existing graph clustering algorithms cannot fully utilize the features and structural information of graph data. This results in efficient and accurate fault case classification and diagnosis.
Patent Information
- Application Number
- CN202411149290.6
- Authority / Receiving Office
- CN · China
- Patent Type
- Patents(China)
- Current Assignee / Owner
- Filing Date
- 2024-08-21
- Publication Date
- 2026-11-17
- Estimated Expiration
- 2044-08-21
AI Technical Summary
In existing technologies, fault diagnosis methods based on graph clustering algorithms cannot fully utilize the feature and structural information of graph data, resulting in inaccurate clustering results and affecting the accuracy of fault case recommendations.
A fault case clustering method based on multi-feature fusion of graph autoencoders is adopted. By combining graph embedding and cluster analysis into a joint optimization strategy, an objective function is defined. The graph embedding learning and node clustering process are closely integrated to optimize the graph embedding and clustering process, generate node embedding representations in low-dimensional space, and determine the cluster center through self-trained clustering units.
It improves the accuracy of node partitioning and clustering efficiency, effectively classifies similar fault cases in low-dimensional space, provides detailed fault diagnosis and solutions, and enhances support for fault prediction, diagnosis and repair.
Smart Images

Figure CN119226509B_ABST
Abstract
Description
Technical Field
[0001] This invention relates to the field of fault diagnosis, and in particular to a clustering method for fault cases of graphic automatic encoders based on multi-feature fusion. Background Technology
[0002] Product failure case data contains a wealth of characteristic information, such as product model, product usage time, and cause of failure. This data can provide support for subsequent fault diagnosis.
[0003] In existing technologies, research on graph clustering algorithms is based on applying classic clustering algorithms, such as k-means or spectral clustering, after graph embedding. Although this two-step framework can solve the problem of graph clustering, it has certain limitations: graph embedding technology can map graph data to a low-dimensional vector space, but it cannot fully utilize the feature and structural information of graph data. Furthermore, single clustering algorithms are usually designed for data in Euclidean space and may not be well adapted to graph data, affecting the final clustering results and leading to inaccurate recommended fault cases.
[0004] Therefore, it is necessary to provide a clustering method for fault cases of graph autoencoders based on multi-feature fusion, so as to optimize the graph embedding and clustering process together, so as to efficiently and accurately divide nodes in the feature space, thereby improving the accuracy of node division and clustering efficiency. Summary of the Invention
[0005] This invention provides a fault case clustering method for a graph autoencoder based on multi-feature fusion, comprising: acquiring multiple fault cases; establishing a fault case graph structure based on the multiple fault cases; determining multiple case clusters and the cluster center of each case cluster based on the fault case graph structure using a case clustering model, wherein the case clustering model includes at least an encoder, a decoder, and a self-trained clustering unit; acquiring current fault description text; determining the embedding representation of the current fault description text; determining a target case cluster based on the embedding representation of the current fault description text and the cluster center of each case cluster; and searching for a target fault case from the target case cluster based on the embedding representation of the current fault description text.
[0006] Furthermore, the step of determining multiple case clusters and the cluster center of each case cluster based on the fault case graph structure using the case clustering model includes: obtaining the embedding representation of each fault case node through the encoder; generating a reconstructed adjacency matrix between any two fault case nodes based on the embedding representation of each fault case node through the decoder; and determining multiple case clusters and the cluster center of each case cluster based on the embedding representation of each fault case node and the reconstructed adjacency matrix between two fault case nodes through the self-trained clustering unit.
[0007] Further, the encoder obtains the embedding representation of each fault case node, including: for each fault case node, aggregating the feature information of the second-order neighbor nodes of the fault case node to generate the embedding representation of the first-order neighbor nodes of the fault case node; aggregating the embedding features of the first-order neighbor nodes to generate the low-dimensional embedding representation of the fault case node; learning the cluster distribution of the fault case nodes based on the low-dimensional embedding representation of the fault case nodes; determining the cluster information vector of the fault case nodes through an attention layer; and generating the embedding representation of the fault case nodes based on the low-dimensional embedding representation and the cluster information vector.
[0008] Furthermore, the cluster information vector of the faulty node is determined based on the following formula: in, Let α be the cluster information vector learned by the i-th fault case node. ij Let W be the attention coefficient of the pooling vector between the i-th faulty node and the j-th cluster, and let W be the weight matrix. Let k be the cluster center of the j-th cluster, k be the number of clusters, and δ be the nonlinear activation function. This represents the weight vector of the attention mechanism. For. || is the vector concatenation operation.
[0009] Furthermore, the objective total loss function of the self-trained clustering unit is: L = L G +αL KL Where L is the target total loss, L G To represent the loss, L KL α is the clustering loss, and α is a coefficient used to balance the representation loss and the clustering loss.
[0010] Furthermore, the loss is represented as: Where n is the total number of faulty node cases, a ij Let be the element in the i-th row and j-th column of the original adjacency matrix. The element in the i-th row and j-th column of the reconstructed adjacency matrix.
[0011] Furthermore, the clustering loss is: Where KL(·) is the KL divergence, Q is the membership distribution, P is the target distribution, and Z is the target distribution. i Let m be the embedding representation of the i-th fault case node. j Let m be the center of the j-th cluster. j′ Let q be the center of the j′-th cluster. ij Let p be the similarity between the embedding representation of the i-th fault case node and the j-th cluster center. ij The target distribution is defined as follows.
[0012] Further, determining the cluster center of the case cluster includes: calculating the weighted average of the embedding representations of all fault case nodes in the case cluster to determine the cluster center of the case cluster.
[0013] Further, determining the target case cluster based on the embedded representation of the current fault description text and the cluster center of each case cluster includes: calculating the cosine similarity between the embedded representation of the current fault description text and the cluster center of each case cluster; and determining the target case cluster based on the cosine similarity between the embedded representation of the current fault description text and the cluster center of each case cluster.
[0014] Further, based on the embedded representation of the current fault description text, searching for a target fault case from the target case cluster includes: calculating the similarity between the embedded representation of the current fault description text and each fault case node included in the target case cluster based on the embedded representation of the current fault description text; and searching for a target fault case from the target case cluster based on the similarity between the embedded representation of the current fault description text and each fault case node included in the target case cluster.
[0015] Compared with existing technologies, the fault case clustering method for graphical autoencoders based on multi-feature fusion provided by this invention has at least the following beneficial effects:
[0016] 1. A method combining graph embedding and clustering analysis is adopted. An objective function is defined through a joint optimization strategy, tightly integrating graph embedding learning with the node clustering process. By jointly optimizing the objective function, the graph embedding and clustering processes are optimized together, enabling efficient and accurate node partitioning in the feature space. This not only improves the accuracy of node partitioning but also enhances clustering efficiency. Cases with similar fault characteristics or performance patterns are embedded into a low-dimensional space through the clustering process, ensuring that these similar fault cases are close in distance in the low-dimensional space, thus facilitating fault classification, analysis, and identification. This clustering method helps extract valuable information from large amounts of fault data, providing strong support for fault prediction, diagnosis, and repair.
[0017] 2. Based on the clustering results and similarity calculations of fault cases, the most similar target case clusters were identified, and target fault cases similar to the current fault description text were found within these clusters. These target fault cases correspond to specific fault cases in the original dataset. To reconstruct complete text cases from the target fault cases, the feature vectors of the nodes were mapped back to the original dataset to extract information including product model, product usage time, fault cause, fault time, fault phenomenon, fault cause, and solution. Finally, this information was recombined into complete text cases to provide users with detailed fault diagnosis and solutions. This method effectively solves the task of finding similar cases based on cluster centers, providing corresponding references and solutions. It considers the global clustering structure while ensuring the accuracy and practicality of the search results. Attached Figure Description
[0018] This specification will be further described by way of exemplary embodiments, which will be described in detail with reference to the accompanying drawings. These embodiments are not limiting; in these embodiments, the same reference numerals denote the same structures, wherein:
[0019] Figure 1 This is a flowchart illustrating a multi-feature fusion-based fault case clustering method for graphical automatic encoders, as shown in some embodiments of this specification.
[0020] Figure 2 This is a schematic diagram of node sampling according to some embodiments of this specification;
[0021] Figure 3 This is a schematic diagram illustrating aggregation learning according to some embodiments of this specification;
[0022] Figure 4 This is a schematic diagram of node embedding results according to some embodiments of this specification. Detailed Implementation
[0023] To more clearly illustrate the technical solutions of the embodiments in this specification, the accompanying drawings used in the description of the embodiments will be briefly introduced below. Obviously, the drawings described below are merely some examples or embodiments of this specification. For those skilled in the art, these drawings can be applied to other similar scenarios without creative effort. Unless obvious from the context or otherwise specified, the same reference numerals in the drawings represent the same structures or operations.
[0024] Figure 1 This is a flowchart illustrating a multi-feature fusion-based fault case clustering method for graphical automatic encoders, as shown in some embodiments of this specification. Figure 1 As shown, the fault case clustering method for graphical autoencoders based on multi-feature fusion may include the following steps.
[0025] Step 110: Obtain multiple fault cases.
[0026] The fault cases may include characteristic information such as product model, product usage time, and cause of the fault.
[0027] Step 120: Based on multiple failure cases, establish a failure case diagram structure.
[0028] As an example only, a fault case diagram structure can be built based on the following process:
[0029] S1. Fault Case Collection: Collect fault cases from multiple channels such as service stations, product manufacturers, customer feedback, and warranty records. Each fault case should include detailed information such as product model, product usage time, cause of fault, fault description, fault phenomenon, and fault solution.
[0030] S2. Data Cleaning: Clean the collected fault cases, remove duplicate, incomplete or erroneous data, and standardize the data to ensure consistency of data format.
[0031] S3. Feature Extraction: Extract key feature information from failure cases, such as product model, product usage time, and cause of failure. Features can be further processed as needed, such as encoding and conversion. The extracted feature information is then organized into structured data for easier subsequent analysis and processing.
[0032] S4. Statistical Analysis: Conduct statistical analysis on failure cases to understand the failure distribution under different product models, product usage durations, and other conditions.
[0033] S5. Graph Structure Construction: In the graph, edges between nodes are constructed according to the following rules: ① Same product model: If two nodes have the same product model, an edge exists between them. ② Similar product usage time: If the usage time of two nodes is similar within a certain range (e.g., the difference in usage time does not exceed 50 hours), an edge exists between them. ③ Same cause of failure: If two nodes have the same cause of failure, an edge exists between them. ④ Same season: If the failure time of two nodes corresponds to the same season, an edge exists between them. ⑤ Similarity of failure phenomenon, failure cause, and solution: Cosine similarity is used to calculate the text similarity of failure phenomenon, failure cause, and solution. In this study, the text similarity threshold is set at 80%. This setting is based on the specific characteristics of failure phenomenon and solution. The descriptions of failure phenomenon and solution are already standardized results after processing by the case knowledge base, possessing a certain quality and consistency. The descriptions are relatively concise and contain specific keywords. Setting the threshold to 80% can effectively distinguish and ensure that only similar failure phenomena are identified as relevant, thereby constructing a more accurate graph structure. If the text similarity of two fault phenomena, fault causes, or solutions exceeds 80%, they are considered to have sufficient similarity, and an edge exists between the two nodes they belong to.
[0034] The graph is defined as G = (V, E, X), where V is the set of fault case nodes, representing the set of fault case nodes V = (v1, v2, ..., v...). n Let E be the set of edges representing a group of edges between faulty case nodes. The topological structure of graph G can be represented by an adjacency matrix A, defined as A∈R. n×n If (v i v j If )∈E, then A i,j =1, otherwise A i,j =0. X = (x1, x2, ..., x n ) is the feature value of the fault case node, where x i ∈R m It is related to the fault case node v i The associated real-valued attribute vectors. The main purpose of attribute graph embedding is to map the nodes of a graph to a low-dimensional space while preserving the topological and feature information of the original attribute graph. The vectors are then applied to node clustering tasks: for a graph G, the goal is to divide the nodes in G into k disjoint groups G = (G1, G2, ..., G...). k This means that nodes within the same cluster are usually close to each other in terms of graph structure, far apart from each other in other aspects, and may have more similar attribute values.
[0035] Step 130: Based on the fault case graph structure, determine multiple case clusters and the cluster center of each case cluster using the case clustering model.
[0036] A case clustering model includes at least an encoder, a decoder, and self-trained clustering units.
[0037] In some embodiments, a case clustering model is used to determine multiple case clusters and the cluster center of each case cluster based on the fault case graph structure, including:
[0038] The encoder is used to obtain the embedded representation of each fault case node;
[0039] The decoder generates a reconstructed adjacency matrix between any two fault case nodes based on the embedding representation of each fault case node.
[0040] By using self-trained clustering units based on the embedded representation of each fault case node and the reconstructed adjacency matrix between two fault case nodes, multiple case clusters and the cluster center of each case cluster are determined.
[0041] In some embodiments, the encoder is used to obtain the embedded representation of each fault case node, including:
[0042] For each fault case node, the feature information of the second-order neighbor nodes of the fault case node is aggregated to generate the embedding representation of the first-order neighbor nodes of the fault case node. The embedding features of the first-order neighbor nodes are aggregated to generate the low-dimensional embedding representation of the fault case node.
[0043] The cluster distribution of fault case nodes is learned based on the low-dimensional embedding representation of fault case nodes, and the cluster information vector of fault case nodes is determined through the attention layer.
[0044] Based on the low-dimensional embedding representation of the fault case node and the cluster information vector, the embedding representation of the fault case node is generated.
[0045] Specifically, in the fault case graph structure, the number of neighbors of fault case nodes may vary greatly. Some fault case nodes may have many neighbors, while some fault case nodes may have very few neighbors. In order to effectively handle neighbor sets of different sizes, the encoder uses a sampling strategy. In order to reduce computational complexity and improve computational efficiency, the encoder adopts local sampling, where each node only needs to consider its surrounding neighbors, which helps to reduce computational complexity. Figure 2 This is a schematic diagram of node sampling according to some embodiments of this specification, such as... Figure 2 As shown, for each fault case node, the entire fault case graph structure is divided into K layers from the inside out. Processing is performed with this fault case node as the center. The hop count K for each fault case node is set to 2. When K = 1, at fault case node v...i Sampling is performed within the first-order neighbor range. After sampling, the neighbor node information is aggregated to generate the embedded representation of the fault case node. Figure 3 These are schematic diagrams illustrating aggregation learning based on some embodiments of this specification, such as... Figure 3 As shown, fault case node v i By aggregating the feature information of sampled second-order neighbor nodes, an embedding representation of first-order neighbor nodes is generated. Then, by aggregating the embedding representations of sampled first-order neighbor nodes, a fault case node v is generated. i A low-dimensional embedding representation. For example, the failure case node v i The characteristic information of the second-order neighbor node and the fault case node v i The feature information of first-order neighbor nodes is merged to ensure that each fault case node includes not only information from direct neighbors but also information from indirect neighbors, thus making the low-dimensional embedding representation more comprehensive. Then, the feature information of these merged second-order neighbor nodes is aggregated together with the feature information of the first-order neighbor nodes into the fault case node, further enriching its low-dimensional embedding representation. Finally, the aggregated low-dimensional embedding representation of the fault case node is processed to generate the final embedding representation of the fault case node.
[0046] To generate the feature representation of the core node, a pooling aggregation function is first learned. This process involves performing a non-linear transformation on the representation vectors of the core node's neighbor nodes, followed by pooling on the transformed feature representation vectors. Next, non-linear transformations are performed on both the pooled node features and the core node's feature representation. Finally, the transformed structures are superimposed to obtain the feature representation of the core node at that layer.
[0047]
[0048]
[0049] in, The feature representation of all neighboring nodes of fault case node v at layer k; k represents the layer number of the fault case graph structure; σ represents the selected nonlinear activation function; W represents the weight matrix; This represents the embedding of the neighbor node u of the fault case node v in layer k; b is the bias. Let N(v) represent the feature representation of faulty case node v at layer k; N(v) is defined as a fixed number of neighbors extracted from all neighboring nodes of faulty case node v. Let L represent the multiple layers used to represent each node, where L is the number of layers, forming the final low-dimensional embedding representation Z of the fault case node. v It contains all the hierarchical information.
[0050] The process of clustering distribution can be represented as follows:
[0051]
[0052] The clustering distribution process is represented by C. t The number of clusters is k, n k It is a case cluster The number of nodes in Z, m is the number of nodes in Z. v The size of the cluster. After learning the cluster distribution, average pooling is performed on each case cluster to obtain representative nodes:
[0053]
[0054] in, These are representative nodes in the case cluster. Concat is the concatenation operation, and MeanPo0ling is the average pooling operation.
[0055] An attention layer was added to further integrate cluster information of faulty case nodes. The attention mechanism captures more important neighbor node features by assigning different weights to different neighbor nodes, and measures the influence vector of each cluster on it.
[0056] In some embodiments, the cluster information vector of the faulty node is determined based on the following formula:
[0057]
[0058]
[0059] in, Let α be the cluster information vector learned by the i-th fault case node. ij Let W be the attention coefficient of the pooling vector between the i-th faulty node and the j-th cluster, and let W be the weight matrix. Let be the cluster center of the j-th case cluster, k be the total number of case clusters, and δ be the nonlinear activation function. This represents the weight vector of the attention mechanism. Let be the low-dimensional embedding representation of the i-th fault case node, and || be the vector concatenation operation.
[0060] Residual blocks are used to fuse the low-dimensional embedding representations of faulty case nodes with cluster information vectors to obtain the final embedding representation:
[0061] Z = Z v +Z c
[0062] Where Z is the embedding representation of the fault case node. Let be the size of the low-dimensional embedding representation of the i-th fault case node. This is the cluster information vector.
[0063] The encoder effectively fuses the topological and feature information of faulty case nodes in the graph and integrates the feature information of their neighboring nodes. By learning the cluster distribution of nodes, cluster information is fused into the embedding generation process, improving the accuracy of the embedding. Through the introduced attention mechanism, the influence of different clusters is fused into the embedding, making the embeddings more similar in the same class and easier to distinguish in different classes.
[0064] Reconstruct the graph using an inner product decoder:
[0065]
[0066] in, z represents the value of the element in the i-th row and j-th column of the reconstructed adjacency matrix. i and z j Let represent the embedding representations of the i-th and j-th fault case nodes, respectively, using the sigmoid activation function. The inner product decoder predicts the connectivity between fault case nodes by calculating the inner product of their embedding representations. The inner product directly measures the similarity of the embedding representations of fault case nodes, reflecting the connection strength between them.
[0067] The decoder can also optimize node embedding through backpropagation so that it can restore node features well.
[0068] In some embodiments, the objective total loss function of the self-trained clustering unit is:
[0069] L = L G +αL KL
[0070] Where L is the target total loss, L G To represent the loss, primarily to minimize the cross-entropy between the reconstructed adjacency matrix and the original adjacency matrix, L KL α is the clustering loss, and α is a coefficient used to balance the representation loss and the clustering loss.
[0071] In some embodiments, the loss is represented as:
[0072]
[0073] Where n is the total number of faulty node cases, a ij Let be the element in the i-th row and j-th column of the original adjacency matrix. The element in the i-th row and j-th column of the reconstructed adjacency matrix.
[0074] In some embodiments, the clustering loss is:
[0075]
[0076]
[0077]
[0078] Where KL(·) is the KL divergence, Q is the membership distribution, P is the target distribution, and Z is the target distribution. i Let m be the embedding representation of the i-th fault case node. j Let m be the center of the j-th cluster. j′ Let q be the center of the j′-th cluster. ij Let p be the similarity between the embedding representation of the i-th fault case node and the j-th cluster center. ij The target distribution is defined as follows.
[0079] Figure 4 This is a schematic diagram illustrating the node embedding results according to some embodiments of this specification, such as... Figure 4 As shown, the clustering results are obtained from the final optimized Q, and for the fault case node v i Assign a label:
[0080]
[0081] Among them, u i Let argmax be the label of the i-th fault case node. j q ij The index is used to select the cluster of cases with the highest similarity.
[0082] Self-trained clustering units aggregate highly similar cases into the same cluster, forming subgraphs with clear internal connections.
[0083] In some embodiments, determining the cluster center of the case cluster includes:
[0084] Calculate the weighted average of the embedding representations of all fault case nodes in the case cluster to determine the cluster center of the case cluster. For example:
[0085]
[0086] Where |C| represents the number of faulty case nodes in the case cluster, f x c is the embedding representation of fault case x in the case cluster. C It is the cluster center of the case cluster.
[0087] Step 140: Obtain the current fault description text.
[0088] The current fault description text may include information such as fault characteristics.
[0089] Step 150: Determine the embedded representation of the current fault description text.
[0090] The input current fault description text is vectorized, requiring the same embedding method as step 130 to convert it into an embedding representation. After inputting the current fault description text and other information (e.g., product model, product usage time, etc.), a unique ID is assigned to it as a sample point in the case space. The current fault description text and other information are used as features to construct graph data with this sample point. The BERT (Bidirectional Encoder Representations from Transformers) model is used to convert the input current fault description text into a high-dimensional vector representation y. The GA-NNF (GraphAuto-encoder Based on Neighbor Node Features) encoder layer is used to embed the high-dimensional vector representation y into the same low-dimensional vector space as the fault case nodes. The embedding process can be represented as follows:
[0091] Z y =GANNF(A,Y)
[0092] Among them, Z y A is the embedded representation of the current fault description text in a low-dimensional space, A is the adjacency matrix of the fault case graph structure, and Y is the feature matrix of the nodes in the graph, including the features of y and other nodes.
[0093] Step 160: Determine the target case cluster based on the embedded representation of the current fault description text and the cluster center of each case cluster.
[0094] Specifically, it includes:
[0095] Calculate the cosine similarity between the embedded representation of the current fault description text and the cluster center of each case cluster;
[0096] Based on the embedded representation of the current fault description text and the cosine similarity between the cluster centers of each case cluster, the target case cluster is determined. For example, the case cluster containing the cluster center with the highest cosine similarity can be used as the target case cluster.
[0097] For example, the cosine similarity between the embedded representation of the current fault description text and the cluster centers of each case cluster can be calculated based on the following formula:
[0098]
[0099] Among them, Similarity(Z) y Z CZ is the cosine similarity between the embedding representation of the current fault description text and the embedding representation of the cluster center of each case cluster, where Z y Z is the embedded representation of the current fault description text. C This is the embedding representation of the cluster center of the case cluster.
[0100] In some embodiments, the target case cluster can also be determined based on the following process:
[0101] Multiple failure cases are sampled from each case cluster to serve as sample failure cases;
[0102] For each sample failure case, calculate the cosine similarity between the embedding representation of the sample failure case and the cluster center of each case cluster. Based on the cosine similarity between the embedding representation of the sample failure case and the cluster center of each case cluster, generate a similarity sequence corresponding to the sample failure case. In the similarity sequence, each element represents the cosine similarity between the embedding representation of the sample failure case and the cluster center of a case cluster.
[0103] Calculate the cosine similarity between the embedded representation of the current fault description text and the cluster center of each case cluster;
[0104] The cosine similarity variance is calculated based on the embedded representation of the current fault description text and the cosine similarity between the cluster centers of each case cluster.
[0105] When the cosine similarity variance is greater than the variance threshold, the case cluster containing the cluster center with the highest cosine similarity can be used as the target case cluster.
[0106] When the cosine similarity variance is less than or equal to the variance threshold, a similarity sequence corresponding to the current fault description text is generated based on the cosine similarity between the embedded representation of the current fault description text and the cluster center of each case cluster. The sequence similarity between the similarity sequence corresponding to the current fault description text and the similarity sequence corresponding to each sample fault case is calculated. Based on the cosine similarity between the embedded representation of the current fault description text and the cluster center of each case cluster, and the sequence similarity between the similarity sequence corresponding to the current fault description text and the similarity sequence corresponding to each sample fault case, the matching score of each case cluster is determined. If there is at least one case cluster with a matching score greater than the matching score threshold, then the case cluster with the matching score greater than the matching score threshold is taken as the target case cluster. If there is no case cluster with a matching score greater than the matching score threshold, then the case cluster with the largest matching score is taken as the target case cluster.
[0107] For example, the cosine similarity variance can be calculated based on the following formula:
[0108]
[0109] Where, σ Similarity Let cosine similarity be the variance, and Similarity(Z) be the variance. y Z C(i) ) represents the cosine similarity between the embedded representation of the current fault description text and the embedded representation of the cluster center of the i-th case cluster, where I is the total number of case clusters.
[0110] Sequence similarity can be calculated using the following formula:
[0111]
[0112] Among them, S j Similarity(Z) is the sequence similarity between the similarity sequence corresponding to the current fault description text and the similarity sequence corresponding to the j-th sample fault case. j Z C(i) ) represents the cosine similarity between the embedded representation of the current fault description text and the embedded representation of the j-th sample fault case.
[0113] The matching score of the case cluster can be calculated based on the following formula:
[0114]
[0115] Among them, M i Let α1 and α2 be the matching score of the i-th case cluster, where α1 and α2 are weights, and α1 + α2 = 1, and both α1 and α2 are greater than 0. J is the total number of sample fault cases included in the i-th case cluster.
[0116] Understandably, the above process relies not only on a single cosine similarity to determine the target case cluster, but also considers the sequence similarity of similarity sequences. This multi-dimensional evaluation method can more comprehensively reflect the similarity relationship between the fault description text and each cluster, thereby improving the accuracy of cluster assignment. By introducing a variance threshold and a matching score threshold, this process can adaptively handle data distributions of varying complexity. When the cosine similarity variance is small, clusters are further distinguished by comparing the sequence similarity of similarity sequences; while when the cosine similarity variance is large, the cluster with the highest cosine similarity is directly selected as the target. When the cosine similarity variance is small, calculating the sequence similarity of similarity sequences allows for a more detailed comparison of the similarity distribution between the current fault description text and the sample fault cases, thereby reducing misclassification caused by similar single similarity values. By setting a matching score threshold, a cluster is only identified as the target case cluster when its matching score is significantly higher than other clusters. This mechanism helps improve the robustness and stability of clustering, preventing fluctuations in results caused by minor differences.
[0117] Step 170: Based on the embedded representation of the current fault description text, find the target fault case from the target case cluster.
[0118] Specifically, it includes:
[0119] Based on the embedding representation of the current fault description text, calculate the similarity between the embedding representation of the current fault description text and each fault case node included in the target case cluster;
[0120] Based on the similarity between the embedded representation of the current fault description text and each fault case node included in the target case cluster, the target fault case is found from the target case cluster.
[0121] For example, the similarity between the embedded representation of the current fault description text and each fault case node included in the target case cluster can be calculated based on the following formula:
[0122]
[0123] Among them, Z x For the embedding representation of faulty case nodes x included in the target case cluster, Similarity(Z) y Z x ) represents the similarity between the embedded representation of the current fault description text and each fault case node included in the target case cluster.
[0124] As an example only, a similarity threshold of 60% is set, and fault case nodes exceeding this threshold are selected as target fault cases for recommendation. The GA-NNF decoder layer is used to decode the target fault cases, extracting information including product model, product usage duration, cause of failure, time of failure, fault symptoms, cause of failure, and solution, and then outputting the results.
[0125] Finally, it should be understood that the embodiments described in this specification are merely illustrative of the principles of the embodiments described herein. Other variations may also fall within the scope of this specification. Therefore, alternative configurations of the embodiments described herein are intended to be illustrative rather than limiting, and should be considered consistent with the teachings of this specification. Accordingly, the embodiments described herein are not limited to those explicitly introduced and described herein.
Claims
1. A clustering method for fault cases in graphical autoencoders based on multi-feature fusion, characterized in that, include: Obtain multiple failure cases; Based on the aforementioned multiple failure cases, a failure case diagram structure is established; Based on the fault case graph structure, a case clustering model is used to determine multiple case clusters and the cluster center of each case cluster. The case clustering model includes at least an encoder, a decoder, and a self-trained clustering unit. Get the current fault description text; Determine the embedded representation of the current fault description text; Based on the embedded representation of the current fault description text and the cluster center of each case cluster, the target case cluster is determined; Based on the embedded representation of the current fault description text, the target fault case is found from the target case cluster; The step of determining multiple case clusters and the cluster center of each case cluster based on the fault case graph structure using a case clustering model includes: The encoder is used to obtain the embedded representation of each fault case node; The decoder generates a reconstructed adjacency matrix between any two fault case nodes based on the embedded representation of each fault case node. The self-trained clustering unit determines multiple case clusters and the cluster center of each case cluster based on the embedded representation of each fault case node and the reconstructed adjacency matrix between two fault case nodes. The encoder is used to obtain the embedded representation of each fault case node, including: For each fault case node, the feature information of the second-order neighbor nodes of the fault case node is aggregated to generate the embedding representation of the first-order neighbor nodes of the fault case node, and the embedding features of the first-order neighbor nodes are aggregated to generate the low-dimensional embedding representation of the fault case node. The cluster distribution of the fault case nodes is learned based on the low-dimensional embedding representation of the fault case nodes, and the cluster information vector of the fault case nodes is determined through an attention layer. Based on the low-dimensional embedding representation of the fault case node and the cluster information vector, the embedding representation of the fault case node is generated.
2. The method for clustering fault cases in a graphical autoencoder based on multi-feature fusion according to claim 1, characterized in that, The cluster information vector of the faulty node is determined based on the following formula: in, This is the cluster information vector learned by the i-th fault case node. For the i-th fault case node and the i-th fault case node Attention coefficients of pooling vectors between clusters of cases This is the weight matrix. For the first The cluster centers of the case clusters, The total number of case clusters. It is a non-linear activation function. This represents the weight vector of the attention mechanism. Let be the low-dimensional embedding representation of the i-th fault case node. This is a vector concatenation operation.
3. The method for clustering fault cases in a graphical autoencoder based on multi-feature fusion according to claim 1 or 2, characterized in that, The objective total loss function of the self-trained clustering unit is: in, Total loss to target To indicate the loss, For clustering loss, This is a coefficient used to balance the representation loss and clustering loss.
4. The method for clustering fault cases in a graphical autoencoder based on multi-feature fusion according to claim 3, characterized in that, The loss is represented as: in, This represents the total number of faulty nodes. The first adjacency of the original adjacency matrix Line number Column elements, For the reconstructed adjacency matrix, the first... Line number The elements of the column.
5. The method for clustering fault cases in a graphical autoencoder based on multi-feature fusion according to claim 3, characterized in that, The clustering loss is: in, Let KL divergence be the KL divergence. It is a subordinate distribution. For the target distribution, Let be the embedding representation of the i-th fault case node. For the j-th cluster center, For the first Cluster center, Let be the similarity between the embedding representation of the i-th fault case node and the j-th cluster center. The target distribution is defined as follows.
6. The method for clustering fault cases in a graphical autoencoder based on multi-feature fusion according to claim 1 or 2, characterized in that, Determining the cluster centers of the case clusters includes: Calculate the weighted average of the embedding representations of all fault case nodes in the case cluster to determine the cluster center of the case cluster.
7. The method for clustering fault cases in a graphical autoencoder based on multi-feature fusion according to claim 1 or 2, characterized in that, Based on the embedded representation of the current fault description text and the cluster center of each case cluster, the target case cluster is determined, including: Calculate the cosine similarity between the embedded representation of the current fault description text and the cluster center of each case cluster; The target case cluster is determined based on the embedded representation of the current fault description text and the cosine similarity between the cluster centers of each case cluster.
8. The method for clustering fault cases in a graphical autoencoder based on multi-feature fusion according to claim 1 or 2, characterized in that, Based on the embedded representation of the current fault description text, the target fault case is located from the target case cluster, including: Based on the embedding representation of the current fault description text, calculate the similarity between the embedding representation of the current fault description text and each fault case node included in the target case cluster; Based on the similarity between the embedded representation of the current fault description text and each fault case node included in the target case cluster, the target fault case is searched from the target case cluster.
