Community discovery method based on graph convolutional neural network based on node structure features

Abstract

The present invention discloses a community discovery method based on a graph convolutional neural network with node structural features. First, different types of nodes are mapped to the same space, and the node features are obtained using a GCN model. Then, the structural features of the nodes are considered from the two aspects of heterogeneity and overlap. Next, the target node representations under three angles are stacked, and the final target node representation is generated using MLP. Finally, the nodes are divided into communities using the k-means clustering algorithm. The present invention considers the node structural features from the two perspectives of heterogeneity and overlap, and considers the node representation from the two aspects of node features and node structural features, providing a new perspective for learning node representation, improving the quality of node representation, ensuring the accuracy of community discovery, and having important significance for various fields such as personalized recommendation and community fraud detection.

Description

Technical Field

[0001] The present invention belongs to the technical field of data mining and relates to a community discovery method of a graph convolutional neural network based on node structure features. Background Art

[0002] Real-world networks like social networks and biological networks are often modeled as graphs. This has led to the widespread use of graph structures in many fields and has also fostered the emergence of graph data mining techniques. Community detection is a common and popular research area. It aims to discover clusters of nodes with high cohesion—that is, nodes in the same cluster are more densely connected than nodes in different clusters, also known as node clustering. Community detection not only helps reveal the structural characteristics of graphs but also has important practical significance and application value in areas such as fraud detection, social networks, and personalized recommendations.

[0003] In real life, community networks can be viewed as heterogeneous and overlapping graphs. Over the past few decades, numerous community discovery methods have been proposed and demonstrated varying degrees of performance. The emerging field of graph deep learning shows great promise in designing more accurate and scalable algorithms. Most researchers use GNNs to learn low-dimensional representations of nodes. In recent years, GNNs have evolved into four types: graph recurrent neural networks (GRNNs), graph attention networks (GATs), graph convolutional networks (GCNs), and graph autoencoders (GAEs). Although these models differ in their frameworks, they all fundamentally implement node representations through two operations. Compared to traditional methods, GNNs have demonstrated promising performance in tasks such as node classification, node clustering, and graph classification. However, these solutions may not perform well on many real-world graphs with multiple node and edge types. Learning node representations in a low-dimensional space while preserving heterogeneous structure and semantics for downstream tasks has attracted widespread attention. Therefore, there is still significant room for improvement in node learning on heterogeneous graphs. Several existing community detection methods share a common shortcoming: they only study the special case of non-overlapping communities, and GNNs rely heavily on smooth node features rather than graph structure, where structural information, such as overlapping neighborhoods, degree, and shortest paths, is crucial. To address this limitation, this paper considers its overlap and learns useful structural features from the adjacency matrix to form better node representations. Summary of the Invention

[0004] Purpose of the invention: To make up for the shortcomings of existing methods, the purpose of the present invention is to provide a community discovery method based on graph convolutional neural networks with node structure features, obtain node structure features from the two aspects of heterogeneity and overlap, use the GCN model to directly obtain node features, and finally combine the node features and node structure features to obtain a more accurate node feature vector, thereby improving the accuracy of community detection.

[0005] Technical solution:

[0006] The community discovery method of graph convolutional neural network based on node structure features includes the following steps:

[0007] 1. Preprocess the graph and map different types of nodes in the graph into the same latent space;

[0008] 2. Use the GCN model to learn the first node feature of the target node;

[0009] 3. Divide the graph into M relational subgraphs based on the edge relationship type. For each relational subgraph, use the GCN model to obtain the feature vector of the target node under different relations. Use the multi-head attention mechanism to aggregate the node features under multiple relations to form the second node feature.

[0010] 4. Considering the characteristics of overlapping neighbors between nodes, the structural representation of the nodes is obtained based on the adjacency matrix, forming a structural feature matrix of the nodes. Considering multi-order neighbor relationships, a multi-order adjacency matrix is formed. Based on the structural feature matrix and the adjacency matrix, a node representation matrix is formed at each level. Finally, a multi-layer perceptron is used to connect them to form the third node feature.

[0011] 5. Stack the first node feature, the second node feature, and the third node feature, and output the final node representation model through the multi-layer perceptron;

[0012] 6. Use the cross entropy loss function to train the proposed node representation model;

[0013] 7. Use the k-means clustering method to cluster nodes into communities and implement community detection.

[0014] Furthermore, in step 1, each node in the graph is mapped to the same latent vector space, and then the data is preprocessed and split into a training set, a test set, and a validation set. The specific steps are as follows:

[0015] Step 1-1: Define the graph used for the community network as G = (V, E, T v ,T e ), which contains multiple node types T v Multiple nodes V and multiple edge types T e The edge E of the graph has multiple edge types |T e |>1, edge type mapping function: The number of nodes is N, and the neighbors of node v are represented by N (v) , e uv Represents the connection edge from node u to v; for any node v, its neighbor node set is represented as use Represents the initial node feature matrix, and the initial feature vector of node v is Apply a specific type of linear transformation to different types of nodes and map them into the same latent space to form the mapped matrix H.

[0016] For t∈T v A node v∈V t have:

[0017]

[0018] Where W t is the trainable weight matrix under the t relationship, is the initial eigenvector of node v under relation t.

[0019] For a node v with multiple types at the same time, there are:

[0020]

[0021] Step 1-2: Divide the dataset into training set, validation set, and test set for experimentation.

[0022] Furthermore, in step 2, the node features are first obtained and the two-layer GCN model is directly used to process the nodes. The specific method is as follows:

[0023]

[0024] Among them, w0, w1, w2 and w3 are trainable weight matrices, σ is the RELU activation function, After two layers of GCN, node v is represented by b v .

[0025] Furthermore, in step 3, the graph is divided into M relational subgraphs according to the edge relationship type of the graph; for each relational subgraph, the GCN model is used to obtain the feature vector of the target node under different relationships; and the multi-head attention mechanism is used to aggregate the node features under multiple relationships to form the second node feature. The specific steps are as follows:

[0026] Step 3-1: Divide the graph into M subgraphs based on the different types of edge relationships between nodes, and use the GCN model to obtain the target node representation in each subgraph.

[0027] For the relationship I∈T e The node v in the partitioned subgraph is represented as:

[0028]

[0029] Among them, w4, w5, w6 and w7 are trainable weight matrices, After two layers of GCN, node v is represented as

[0030] Step 3-2: Use the attention mechanism to assign different weights to target nodes under different relationships and fuse the representations of target nodes v under different relationships. Assume that the relationship set is p v , the attention mechanism formula is as follows:

[0031]

[0032]

[0033] Among them, q T is the query vector, is the importance score of node v under relation p, is the attention coefficient of node v under relation I.

[0034] Step 3-3: Use an additional linear transformation and a nonlinear function to map the node embeddings to a vector space with the desired output dimension:

[0035]

[0036] Among them, w8 is the trainable weight matrix, is the feature of node v aggregating multiple relations in the mapping space, d v It is the second node feature.

[0037] Furthermore, in step 4, the characteristics of overlapping neighbors between nodes are considered, and the structural representation of the node is obtained based on the adjacency matrix to form the structural feature matrix of the node; multi-order neighbor relationships are considered to form a multi-order adjacency matrix, and based on the structural feature matrix and the adjacency matrix, a node representation matrix is formed at each level. Finally, a multi-layer perceptron is used to connect them to form the third node feature. The specific steps are as follows:

[0038] Step 4-1: Combine node features and edge features to derive node structure features:

[0039]

[0040] Among them, A ij is the adjacency matrix, N i is the set of neighbor nodes of node i, function

[0041] Step 4-2: Use the structural feature vector q v Generate a diagonal matrix Q v :

[0042] Q=diag(q)#(10)

[0043] Step 4-3: Aggregate the features of neighbors through the unnormalized adjacency matrix A:

[0044] r=AQ#(11)

[0045] According to the multi-order adjacency matrix formula (12), considering multi-hop overlapping neighbors, the characteristics after aggregating multi-order neighbors can be obtained:

[0046] A (m) =A (m-1) A (1) #(12)

[0047] r (m) =A (m) Q#(13)

[0048] Step 4-4: Use the attention mechanism to assign different weights to target nodes under different relationships and fuse the node representations under different relationships:

[0049]

[0050] in, is the query vector, is the importance score of node v at order n, is the attention coefficient of node v at order n.

[0051] Step 4-5: Use an additional linear transformation and a nonlinear function to map the node embeddings to a vector space with the desired output dimension:

[0052] R=σ(w9·R r )#(17)

[0053] Among them, w9 is the trainable weight matrix, the i-th row of R, r i represents the structural feature vector of node i, then the structural feature vector of node v is represented by r v .

[0054] Furthermore, in step 5, the first node feature, the second node feature, and the third node feature are stacked and the final node representation model is output through a multi-layer perceptron. The specific steps are as follows:

[0055] Step 5-1: Stack the first node feature, the second node feature, and the third node feature to form the input of the multi-layer perceptron:

[0056] h v =concat(b v ,d v ,r v)#(18)

[0057] Step 5-2: Use a multi-layer perceptron to form the final target node representation:

[0058]

[0059] Represents the final embedding representation of the target node v

[0060] Furthermore, in step 6, the proposed node representation model is trained using a cross entropy loss function. The specific steps are as follows:

[0061] Using semi-supervised learning, guided by a small set of labeled nodes, the model weights are optimized by backpropagation and gradient descent to minimize cross entropy, thereby learning meaningful node embeddings. The loss function is defined as:

[0062]

[0063] Where C is the community set, y v [c] is the real community to which node v belongs, The predicted community of node v, V L is a collection of nodes with labels.

[0064] Furthermore, in step 7, the k-means clustering method is used to cluster the nodes into communities to achieve community detection. The specific steps are as follows:

[0065] Step 7-1: Select k objects from the data as initial cluster centers;

[0066] Step 7-2: Calculate the distance between each cluster object and each cluster center respectively, and divide the cluster objects into the class closest to the cluster center, and divide them into k clusters;

[0067] Step 7-3: Calculate the average value of K cluster samples as the new centroid;

[0068] Step 7-4: Loop through steps 7-2 and 7-3 until the centroid position remains unchanged, then the algorithm stops.

[0069] Beneficial Effects: This invention approaches both node features and node structural features to learn better node representations, thereby improving the accuracy of community detection. First, different types of nodes are mapped to the same space. Then, the GCN model is directly used to obtain node features. Next, the structural features of the nodes are considered from the perspectives of heterogeneity and overlap. Regarding heterogeneity, multiple subgraphs are first partitioned based on the edge relationships between nodes. Multiple GCN models are then used to obtain target node representations under different edge relationships. Next, an attention mechanism is used to aggregate multiple representations of the target node. Finally, these representations are mapped to the desired dimensional space to form the target node representation for that view. Regarding overlap, node structural features are first obtained using a heuristic algorithm. Next, the adjacency matrix A is used to aggregate neighbor features of different orders. Next, an attention mechanism is used to aggregate multi-order neighbor features. Finally, these representations are mapped to the desired dimensional space to generate the target node representation for that view. Finally, the target node representations from the three perspectives are stacked, and the MLP is used to generate the final target node representation. BRIEF DESCRIPTION OF THE DRAWINGS

[0070] Figure 1 It is a schematic diagram of the steps of the present invention.

[0071] Figure 2 It is the overall model framework diagram of the present invention.

[0072] Figure 3 It is a flow chart of computing node characteristics of the present invention.

[0073] Figure 4 It is a flow chart of the present invention for calculating node structural features based on heterogeneity.

[0074] Figure 5 It is a flow chart of calculating node structural features based on overlap in the present invention. DETAILED DESCRIPTION

[0075] The present invention is further described below with reference to the accompanying drawings. The community discovery method based on a graph convolutional neural network with node structure features comprises the following steps:

[0076] The overall process is as follows Figure 2 As shown,

[0077] Step 1: Map each node in the graph to the same latent vector space, then preprocess the data and split it into training, test, and validation sets. The specific steps are as follows:

[0078] Step 1-1: Define the graph used for the community network as G = (V, E, T v ,T e ), which contains multiple node types T vMultiple nodes V and multiple edge types T e The edge E of the graph has multiple edge types |T e |>1, edge type mapping function: The number of nodes is N, and the neighbors of node v are represented by N (v) , e uv Represents the connection edge from node u to v. For any node v, its neighbor node set can be represented as use Represents the initial node feature matrix, and the initial feature vector of node v is Apply a specific type of linear transformation to different types of nodes and map them into the same latent space to form the mapped matrix H.

[0079] For t∈T v A node v∈V t have:

[0080]

[0081] Where W t is the trainable weight matrix under the t relationship, is the initial eigenvector of node v under relation t.

[0082] For a node v with multiple types at the same time, there are:

[0083]

[0084] Step 1-2: Divide the dataset into training set, validation set, and test set for experimentation.

[0085] Step 2: The flowchart of this step is as follows Figure 3 As shown, first obtain the node features, and directly use the two-layer GCN model to process the nodes. The specific method is as follows:

[0086]

[0087] Where, w0, w1, w2 and w3 are trainable weight matrices, σ is the RELU activation function, After two layers of GCN, node v is represented by b v .

[0088] Step 3: The flowchart of this step is as follows Figure 4 As shown in the figure, according to the edge relationship type of the graph, the graph is divided into M relationship subgraphs; for each relationship subgraph, the GCN model is used to obtain the feature vector of the target node under different relationships; the multi-head attention mechanism is used to aggregate the node features under multiple relationships to form the second node feature. The specific steps are as follows:

[0089] Step 3-1: Divide the graph into M subgraphs based on the different types of edge relationships between nodes, and use the GCN model to obtain the target node representation in each subgraph.

[0090] For the relationship I∈T e The node v in the partitioned subgraph is represented as:

[0091]

[0092] Among them, w4, w5, w6 and w7 are trainable weight matrices, After two layers of GCN, node v is represented as

[0093] Step 3-2: Use the attention mechanism to assign different weights to target nodes under different relationships and fuse the representations of target nodes v under different relationships. Assume that the relationship set is P v , the attention mechanism formula is as follows:

[0094]

[0095] Among them, q T is the query vector, is the importance score of node v under relation p, is the attention coefficient of node v under relation I.

[0096] Step 3-3: Use an additional linear transformation and a nonlinear function to map the node embeddings to a vector space with the desired output dimension:

[0097]

[0098] Among them, w8 is the trainable weight matrix, is the feature of node v aggregating multiple relations in the mapping space, d v It is the second node feature.

[0099] Step 4: The flowchart of this step is as follows Figure 5 As shown in the figure, considering the characteristics of overlapping neighbors between nodes, the structural representation of the node is obtained based on the adjacency matrix to form the structural feature matrix of the node; considering multi-order neighbor relationships, a multi-order adjacency matrix is formed. Based on the structural feature matrix and the adjacency matrix, a node representation matrix is formed at each level. Finally, a multi-layer perceptron is used to connect them to form the third node feature. The specific steps are as follows:

[0100] Step 4-1: Combine node features and edge features to derive node structure features:

[0101]

[0102] Among them, A ij is the adjacency matrix, N i is the set of neighbor nodes of node i, function

[0103] Step 4-2: Use the structural feature vector q v Generate a diagonal matrix Q v :

[0104] Q=diag(q)#(10)

[0105] Step 4-3: Aggregate the features of neighbors through the unnormalized adjacency matrix A:

[0106] r=AQ#(11)

[0107] According to the multi-order adjacency matrix formula (12), considering multi-hop overlapping neighbors, the characteristics after aggregating multi-order neighbors can be obtained:

[0108] A (m) =A (m-1) A (1) #(12)

[0109] r (m) =A (m) Q#(13)

[0110] Step 4-4: Use the attention mechanism to assign different weights to target nodes under different relationships and fuse the node representations under different relationships:

[0111]

[0112] in, is the query vector, is the importance score of node v at order n, is the attention coefficient of node v at order n.

[0113] Step 4-5: Use an additional linear transformation and a nonlinear function to map the node embeddings to a vector space with the desired output dimension:

[0114] R=σ(w9·R r )#(17)

[0115] Among them, w9 is the trainable weight matrix, the i-th row of R, r i represents the structural feature vector of node i, then the structural feature vector of node v is represented by r v .

[0116] Step 5: Stack the first node feature, the second node feature, and the third node feature, and output the final node representation model through the multi-layer perceptron. The specific steps are as follows:

[0117] Step 5-1: Stack the first node feature, the second node feature, and the third node feature to form the input of the multi-layer perceptron:

[0118] h v =concat(b v ,d v ,r v )#(18)

[0119] Step 5-2: Use a multi-layer perceptron to form the final target node representation:

[0120]

[0121] Represents the final embedding representation of the target node v

[0122] Step 6: Use the cross entropy loss function to train the proposed node representation model. The specific steps are as follows:

[0123] Using semi-supervised learning, guided by a small set of labeled nodes, the model weights are optimized by backpropagation and gradient descent to minimize cross entropy, thereby learning meaningful node embeddings. The loss function is defined as:

[0124]

[0125] Where C is the community set, y v [c] is the real community to which node v belongs, The predicted community of node v, V L is a collection of nodes with labels.

[0126] Step 7: Use the k-means clustering method to cluster nodes into communities and implement community detection. The specific steps are as follows:

[0127] Step 7-1: Select k objects from the data as initial cluster centers;

[0128] Step 7-2: Calculate the distance between each cluster object and each cluster center respectively, and divide the cluster objects into the class closest to the cluster center, and divide them into k clusters;

[0129] Step 7-3: Calculate the average value of K cluster samples as the new centroid;

[0130] Step 7-4: Loop through steps 7-2 and 7-3 until the centroid position remains unchanged, then the algorithm stops.

Claims

1. A community discovery method based on graph convolutional neural network with node structure features, characterized in that: The method comprises the following steps: Step 1: Preprocess the graph and map different types of nodes in the graph into the same latent space; Step 2: Use the GCN model to learn the first node feature of the target node; Step 3: Divide the graph into M relational subgraphs according to the edge relationship type. For each relational subgraph, use the GCN model to obtain the feature vector of the target node under different relations. Use the multi-head attention mechanism to aggregate the node features under multiple relations to form the second node feature. Step 4: Considering the characteristics of overlapping neighbors between nodes, the structural representation of the node is obtained according to the adjacency matrix to form the structural feature matrix of the node; Considering multi-order neighbor relationships, a multi-order adjacency matrix is formed. Based on the structural feature matrix and the adjacency matrix, a node representation matrix is formed at each level. Finally, a multi-layer perceptron is used to connect them to form the third node feature. Step 5: Stack the first node feature, the second node feature, and the third node feature, and output the final node representation model through the multi-layer perceptron; Step 6: Use the cross entropy loss function to train the node representation model; Step 7: Use the k-means clustering method to cluster each node into communities to achieve community detection; The specific steps of step 1 are as follows: Step 1-1: Define the graph used for the community network as G = (V, E, T v ,T e ), which contains multiple node types T v Multiple nodes V and multiple edge types T e The edge E of the graph has multiple edge types |T e |>1, edge type mapping function: The number of nodes is N, and the neighbors of node v are represented by N (v) , e uv Represents the connection edge from node u to v; for any node v, its neighbor node set is represented as use Represents the initial node feature matrix, and the initial feature vector of node v is Apply a specific type of linear transformation to different types of nodes and map them into the same latent space to form the mapped matrix H; For t∈T v A node v∈V t have: Where W t is the trainable weight matrix under the t relationship, is the initial eigenvector of node v under relation t; For a node v with multiple types at the same time, there are: Step 1-2: Divide the dataset into training set, validation set, and test set for experimentation.

2. The community discovery method based on graph convolutional neural network with node structure features according to claim 1 is characterized by: The specific steps of step 2 are as follows: Use a two-layer GCN model to process the node: Among them, w0, w1, w2 and w3 are trainable weight matrices, σ is the RELU activation function, After two layers of GCN, node v is represented by b v .

3. The community discovery method based on graph convolutional neural network with node structure features according to claim 2 is characterized by: The specific steps of step 3 are as follows: Step 3-1: Divide the graph into M subgraphs based on the different types of edge relationships between nodes. Use the GCN model to obtain the target node representation in each subgraph. For the relationship I∈T e The node v in the partitioned subgraph is represented as: Among them, w4, w5, w6 and w7 are trainable weight matrices, After two layers of GCN, node v is represented as Step 3-2: Use the attention mechanism to assign different weights to target nodes under different relationships and fuse the representations of target nodes v under different relationships; assuming that the relationship set is P v , the attention mechanism formula is as follows: Among them, q T is the query vector, is the importance score of node v under relation p, is the attention coefficient of node v under relation I; Step 3-3: Use an additional linear transformation and a nonlinear function to map the node embeddings to a vector space with the desired output dimension: Among them, w8 is the trainable weight matrix, is the feature of node v aggregating multiple relations in the mapping space, d v It is the second node feature.

4. The community discovery method based on graph convolutional neural network with node structure features according to claim 3 is characterized by: The specific steps of step 4 are as follows: Step 4-1: Combine node features and edge features to derive node structure features: Among them, A ij is the adjacency matrix, N i is the set of neighbor nodes of node i, function Step 4-2: Use the structural feature vector q v Generate a diagonal matrix Q v : Q=diag(q)#(10) Step 4-3: Aggregate the features of neighbors through the unnormalized adjacency matrix A: r=AQ#(11) According to the multi-order adjacency matrix formula (12), considering multi-hop overlapping neighbors, the characteristics after aggregating multi-order neighbors are obtained: A (m) =A (m-1) A (1) #(12) r (m) =A (m) Q#(13) Step 4-4: Use the attention mechanism to assign different weights to target nodes under different relationships and fuse the node representations under different relationships: in, is the query vector, is the importance score of node v at order n, is the attention coefficient of node v at order n; Step 4-5: Use an additional linear transformation and a nonlinear function to map the node embeddings to a vector space with the desired output dimension: R=σ(w9·R r )#(17) Among them, w9 is the i-th row of the trainable weight matrix R, r i represents the structural feature vector of node i, then the structural feature vector of node v is represented by r v .

5. The community discovery method based on graph convolutional neural network with node structure features according to claim 4 is characterized in that: The specific steps of step 5 are as follows: Step 5-1: Stack the first node feature, the second node feature, and the third node feature to form the input of the multi-layer perceptron: h v =concat(b v ,d v ,r v )#(18) Step 5-2: Use a multi-layer perceptron to form the final target node representation: Represents the final embedding representation of the target node v 6. The community discovery method based on graph convolutional neural network with node structure features according to claim 5, characterized in that: The specific steps of step 6 are as follows: Using semi-supervised learning, the model weights are optimized by minimizing cross entropy through backpropagation and gradient descent. The loss function is defined as: Where C is the community set, y v [c] is the real community to which node v belongs, The predicted community of node v, V L is a collection of nodes with labels.

7. The community discovery method based on graph convolutional neural network with node structure features according to claim 1, characterized in that: The specific steps of step 7 are as follows: Step 7-1: Select k objects from the data as initial cluster centers; Step 7-2: Calculate the distance between each cluster object and each cluster center respectively, and divide the cluster objects into the class closest to the cluster center, and divide them into k clusters; Step 7-3: Calculate the average value of K cluster samples as the new centroid; Step 7-4: Loop through steps 7-2 and 7-3 until the centroid position remains unchanged, then the algorithm stops.

Images