Convex hull dynamic aggregation message passing type graph neural network and method thereof

Abstract

The invention provides a convex hull dynamic aggregation message passing type graph neural network and a method thereof, and the method comprises the steps: 1, setting a convex hull layer between message passing layers, and reconstructing a neighborhood node set through the convex hull layer according to graph data features before message passing; step 2, expanding a neighborhood node set according to the number of message passing layers, performing feature dimension transformation by using a linear layer and then constructing a convex hull to obtain a convex hull vertex set, and taking the convex hull vertex set as a neighborhood node set of the current message passing layer of a target node; 3, setting a graph convex hull layer in front of the pooling layer of the multi-graph data, and constructing a convex hull for the target graph to obtain a graph convex hull vertex set; according to the method, the problem of excessive smoothness in the graph neural network is relieved, graph structure information is reserved through a dynamic convex hull aggregation mechanism, meanwhile, the distinguishing capacity of node representation is enhanced, and the expression performance of the model is improved.

Description

Technical Field

[0001] This invention belongs to the field of message-passing graph neural network technology, and particularly relates to a convex hull dynamic aggregation message-passing graph neural network and its method. Background Technology

[0002] Graph neural networks (Graph Neural Networks) have been widely applied in recent years in various fields such as social networks, recommender systems, and bioinformatics due to their ability to simultaneously model topological relationships and node attribute information in graph structures. Compared with traditional deep learning methods, Graph Neural Networks have overcome the modeling bottleneck on non-Euclidean structural data, demonstrating significant advantages. Currently, most mainstream Graph Neural Networks are based on message passing mechanisms. This mechanism aggregates information from neighboring nodes iteratively and updates it by combining it with its own features, thereby continuously optimizing the node representation. This framework has become the core paradigm in graph representation learning. However, existing research has shown that as the number of message passing layers increases, node features tend to homogenize during multiple aggregation processes, eventually converging to a fixed point, making it difficult to distinguish between nodes of different categories and severely affecting model performance. This phenomenon is known as the oversmoothing problem, which is one of the main bottlenecks in current Graph Neural Network models. The root cause of the oversmoothing problem lies in the static neighborhood aggregation strategy commonly used in current Graph Neural Networks. This strategy integrates neighbor information in the same way at each layer, lacking the ability to adaptively model structural and semantic differences between nodes. Since aggregation operations are a core component of graph neural networks, their design directly affects the model's ability to capture structural features and maintain node discriminativity. To address the aforementioned issues, this invention proposes a dynamic aggregation mechanism for graph neural networks that incorporates a convex hull structure. This mechanism effectively characterizes the boundary information between nodes and their neighbors by constructing the convex hull of the node's neighborhood, thereby achieving dynamic control over the information aggregation process. This mechanism enhances the discriminativity of node representations while preserving structural features, effectively alleviating the over-smoothing problem caused by repeated aggregation in traditional message passing frameworks. Summary of the Invention

[0003] To optimize the oversmoothing problem in message-passing graph neural networks, this invention proposes a dynamic convex hull aggregation method for message-passing graph neural networks. This method alleviates the convergence of node features and the phenomenon of singular representation caused by the iteration of message-passing layers, solves the oversmoothing problem caused by message passing, and increases the expressive performance of graph neural network models.

[0004] This invention is implemented using the following techniques:

[0005] A message-passing graph neural network with dynamic convex hull aggregation, comprising at least two message layers, a ReLU function model, and fully connected layers; convex hull layers connect the message layers to dynamically update the neighborhood node set of a single graph between message layers; the convex hull layers comprise linear units, neighborhood node units, and a convex hull; wherein the message-passing graph neural network processes graph data including:

[0006] Data preprocessing stage:

[0007] Load single graph data, including initial node feature data, initial edge index data, etc.

[0008] The message layer uses a message passing paradigm to process the initial node feature data based on the initial edge index data;

[0009] The convex hull layer reconstructs the dynamic edge index data by building a convex hull vertex set from the node feature data and the initial edge index data.

[0010] Data loop processing phase:

[0011] The message layer processes the dynamic edge index data and the node feature data of the previous layer according to the message passing paradigm to obtain the node feature data for this time.

[0012] The convex hull layer reconstructs the node feature data output by the previous message layer and the initial edge index data according to the convex hull vertex set to obtain dynamic edge index data;

[0013] The final single graph node feature data is obtained by iterating through the node feature data and dynamic edge index data in all message passing layers and convex hull layers.

[0014] The ReLU function model and the fully connected layer output trained single-graph node feature data.

[0015] Furthermore, the process of obtaining dynamic edge index data in the convex hull layer includes:

[0016] The node feature data output from the message layer is transformed by feature dimension transformation to obtain two-dimensional node feature data;

[0017] The two-dimensional node feature data is divided into nodes based on the initial edge index data and the message passing layer parameter k. The set of neighboring nodes within k hops;

[0018] For nodes The set of neighboring nodes is obtained by constructing the convex hull of the nodes using the following formula. The set of convex hull vertices of any neighboring node:

[0019]

[0020] Among them, nodes The set of neighboring nodes within k hops As input for constructing the convex hull;

[0021] Update graph data features based on the convex hull vertex set. The neighboring nodes that exist in the convex hull vertex set are the neighboring node set of the nodes in the next message passing layer, and dynamically establish the current edge index data.

[0022] The node feature data and dynamic edge index data are used for the next layer of message aggregation operations using the following formula:

[0023]

[0024] in: :node of The set of neighboring nodes within the jump range; :node In the Layer embedding representation; : are non-negative combination coefficients that satisfy the definition conditions of convex hull.

[0025] Furthermore, the message-passing graph neural network further includes: a graph convex hull layer and a pooling layer; the message layer and the ReLU function model are sequentially connected by a graph convex hull layer and a pooling layer to realize dynamic data updates of the neighborhood node set of multiple graphs between the message-passing layers; the graph convex hull layer includes linear units, graph node units, and a graph convex hull; wherein:

[0026] The graph convex hull layer constructs a convex hull vertex set from the node feature data output by the previous message layer and the initial graph index data to reconstruct the dynamic graph edge index data and the node feature data of the dynamic graph.

[0027] The pooling layer performs local region aggregation on the dynamic graph edge index data and outputs multi-graph feature data.

[0028] The ReLU function model and the fully connected layer output the final multi-graph feature data.

[0029] Furthermore, the process of obtaining graph index data by the graph convex hull layer includes:

[0030] Using the node feature data trained through multiple message passing layers and the original graph index data, the node feature data is divided into a graph node feature set. Then, a linear layer is used to transform the feature dimension, resulting in a two-dimensional graph node feature set data, i.e.:

[0031]

[0032] in: :node Two-dimensional features; :picture The set of node features;

[0033] For each 2D graph node feature set Construct the convex hull of the graph and obtain the vertex set of the convex hull of each graph. The vertex set of the convex hull of each graph is a subset of the node feature set of the original graph.

[0034] The set of convex hull vertices of the graph is used as the set of node features of the new graph. The graph index data and node feature data are updated, and node feature data that do not exist in the set of convex hull vertices are deleted. The updated node feature data and graph index data are used as the input of the subsequent pooling layer.

[0035] Furthermore, the message layer loads the graph data and uses a message passing paradigm to process the edge index data to obtain node feature data. The message passing paradigm is as follows:

[0036]

[0037] Where UPDATE and AGGREGATE are differentiable aggregate functions. It is a node convex hull vertex set Dynamic graph data aggregated from various sources.

[0038] This invention can also be implemented using the following technical solutions, including:

[0039] A dynamic aggregation method for the convex hull of a message-passing graph neural network.

[0040] Single-image data message propagation process:

[0041] Step 100: Set a convex hull layer between each message passing layer. Before message passing, use the convex hull layer to reconstruct the neighborhood node set based on the graph data features. The node feature data update adopts a typical message passing paradigm, and its calculation process is shown in formula (1):

[0042] (1)

[0043] Where UPDATE and AGGREGATE are micro-aggregate functions; It is a node convex hull vertex set Aggregated dynamic graph data;

[0044] Step 200: In the convex hull layer, expand the neighborhood node set according to the message passing layer number, and use a linear layer to perform feature dimension transformation to obtain the convex hull vertex set, which serves as the neighborhood node set of the target node in this message passing layer.

[0045] Step 201: The graph data includes node feature data and edge index data. All node feature data undergoes feature dimension transformation through a linear layer to obtain two-dimensional node feature data.

[0046] Step 202: In the In layer propagation, node features are obtained using two-dimensional node feature data. convex hull vertex set to it Within the jump neighborhood nodes Perform an embedding representation and construct its convex hull, i.e.:

[0047] (2)

[0048] Among them: nodes of Set of neighboring nodes within jump As input for constructing the convex hull, the output is a linear representation of the nodes. The set of convex hull vertices of any neighboring node;

[0049] Step 203: Update the graph data features based on the convex hull vertex set. The neighboring nodes that exist in the convex hull vertex set are the neighboring node sets of the nodes in the next message passing layer. Dynamically build the current edge index data and add the target node self-loop to obtain the final dynamic new edge index data.

[0050] Step 204: Use the updated graph data features for the message aggregation operation at the next layer, as shown in formula (3);

[0051] (3)

[0052] in: :node of The set of neighboring nodes within the jump range; :node In the Layer embedding representation; : are non-negative combination coefficients that satisfy the definition conditions of convex hull.

[0053] Furthermore, the message-passing graph neural network includes:

[0054] Multi-image data message propagation process:

[0055] Step 300: Construct the convex hull of the target graph to obtain the vertex set of the convex hull. The target object is transformed from the target node into the target graph, and the updated edge index data is transformed into updated graph index data.

[0056] Step 301: Using the node feature data trained by the multi-layer message passing layer and the original graph index data, the node feature data is divided into a graph node feature set. Then, a linear layer is used to transform the feature dimension to obtain a two-dimensional graph node feature set, i.e.:

[0057]

[0058] in: :node Two-dimensional features; :picture The set of node features;

[0059] Step 302: For each 2D graph node feature set Construct the convex hull of the graph and obtain the vertex set of the convex hull of each graph. The vertex set of the convex hull of each graph is a subset of the node feature set of the original graph.

[0060] Step 303: Use the set of convex hull vertices of the graph as the new set of graph node features, update the graph index data and node feature data, delete node feature data that does not exist in the set of convex hull vertices of the graph, and use the updated node feature data and graph index data as input to the subsequent pooling layer.

[0061] Beneficial effects

[0062] This invention is widely used in message-passing graph neural networks and can be universally applied to various message-passing graph neural network variants, alleviating the over-smoothing problem caused during message-passing layer iteration.

[0063] This invention compares various graph neural network models on the Frankenstein dataset, mainly including classic graph neural network model variants such as GAT, GIN, and GCN, as well as commonly used aggregation functions such as SUM and VPA. Figure 8 The results show a comparison of experimental results after adding the graph convex hull layer. This includes a comparison of experimental results for the original model, updating the graph index data using the convex hull vertex set, and updating the graph index data using the other vertex sets. It can be seen that the experimental results obtained by updating the graph index data using the convex hull vertex set are generally better than the other two cases. The average precision and F1 value of the original model are 0.6061 and 0.6343, respectively, while the average values ​​obtained by updating the graph index data using the convex hull vertex set are 0.6149 and 0.6472, respectively. The average values ​​of the experimental results are all higher than those of the original model. Attached Figure Description

[0064] Figure 1 This is a schematic diagram of the single-graph data graph neural network model structure in this invention;

[0065] Figure 2This is a schematic diagram of the multi-graph data graph neural network model structure in this invention;

[0066] Figure 3 This is a flowchart of the internal flow of the convex hull layer;

[0067] Figure 4 Build a flowchart for the convex hull;

[0068] Figure 5 Flowchart for updating edge indexes;

[0069] Figure 6 Flowchart for constructing the set of neighboring nodes within k hops;

[0070] Figure 7 The diagram shows the internal flow chart of the convex hull layer.

[0071] Figure 8 This is a comparison of experimental results for different graph index data update methods for graph convex hull layers. Detailed Implementation

[0072] The technology and method of the present invention will be described in detail below with reference to implementation examples and accompanying drawings. The following examples and drawings are used to illustrate the structure of the present invention, but are not intended to limit the scope of the present invention.

[0073] The main content of this invention is to add convex hull layers between message-passing layers in a message-passing graph neural network, so that the set of neighboring nodes of the nodes in the input of each message-passing layer is dynamically updated. The graph neural network model flow for single graph data is as follows: Figure 1 As shown. Specifically, for multi-graph data models, a graph convex hull layer is set before the pooling layer to update the graph index data based on the graph data. The graph neural network model flow for multi-graph data is as follows: Figure 2 As shown.

[0074] The specific implementation plan is as follows: In the convex hull layer, the set of neighboring nodes is expanded according to the number of message passing layers. A linear layer is used to transform the feature dimension to obtain two-dimensional node feature data. A set of neighboring nodes is constructed based on the edge index data. A convex hull is constructed for the set of neighboring nodes of each node to obtain a set of convex hull vertices. The edge index data is updated based on the set of convex hull vertices. A graph convex hull layer is set before the pooling layer of multi-graph data to construct a convex hull for the target graph to obtain a set of graph convex hull vertices. The operation is basically similar to that of the convex hull layer, but the target object is changed from the target node to the target graph, and the updated edge index data is changed to updated graph index data.

[0075] Step 0: This step is the initial stage. Load the graph data, set the loop according to the message passing layer parameter, and first call the first message passing layer to update the node feature data according to the message passing paradigm and unified aggregation function.

[0076] Step 1: Pass the node feature data and edge index data into the first convex hull layer; in the convex hull layer, the node feature data is first transformed in feature dimension through a linear layer to obtain two-dimensional node feature data, such as... Figure 3 As shown.

[0077] Step 2: Construct the convex hull for the set of direct neighbors of each node; the Graham scan method is used to construct the convex hull; based on the convex hull principle, the set of neighbors can be divided into the set of convex hull vertices and the set of other neighbors, such as... Figure 4 As shown, the set of convex hull vertices can linearly represent any point in the set of other neighboring nodes; as shown in formula (2).

[0078] (2)

[0079] Among them, nodes The set of neighboring nodes within k hops As input for constructing the convex hull, the output is a linear representation of the nodes. The set of convex hull vertices of any neighboring node.

[0080] Step 3: Update the convex hull vertex set to the latest neighbor set of the target node; update the edge index data according to the latest neighbor set, delete the edge index data between the remaining neighbor nodes and the target node, and the convex hull layer returns the new edge index data. The edge index data update is as follows: Figure 5 As shown.

[0081] Step 4: Use the new edge index data output by the convex hull layer and the node feature data output in Step 0 as input to the lower message passing layer. The lower message passing layer has the same structure as the message passing layer in Step 0, and updates the node feature data according to the message passing paradigm and the unified aggregation function. The node feature data update adopts a typical message passing paradigm, and its calculation process is shown in formula (1):

[0082] (1)

[0083] UPDATE and AGGREGATE can be any differentiable aggregate function, such as SUM, MEAN, MAX and other commonly used aggregate functions. It is a node convex hull vertex set Dynamic graph data aggregated from various sources.

[0084] Step 5: Use the original edge index data and the node feature data output in Step 4 as the input data for this convex hull layer. Similar to Step 1, the node feature data is transformed through a linear layer to obtain two-dimensional node feature data.

[0085] Step 6: Place the 2D node feature data into Euclidean space. For each node, construct a neighborhood node set for its direct neighbors and 1-hop neighbors. Unlike Step 2, this time the neighborhood node set includes not only direct neighbors but also 1-hop neighbors. Similarly, use the Graham scan algorithm to construct the convex hull for each point's neighborhood node set, obtaining the convex hull vertex set for each node. The process for constructing the neighborhood node set within K hops is as follows: Figure 6 As shown.

[0086] Step 7: Update the edge index data of the convex hull vertex set obtained in Step 6, delete all edge index data of the remaining points that do not exist in the convex hull vertex set, and the convex hull layer can return the new edge index data.

[0087] Step 8: Similar to Step 4, use the new edge index data output from the convex hull layer in Step 7 and the new node feature data output from the message passing layer in Step 4 as inputs for this message passing layer, and update the node feature data according to the message passing paradigm and the unified aggregation function. The node feature data update adopts a typical message passing paradigm.

[0088] Step 9: After looping through all message passing layers and convex hull layers, and obtaining the final node feature data, if the dataset is a single graph dataset, it can be directly passed through ReLU and fully connected layers to output the data. If the dataset is a multi-graph dataset, it needs to go through an additional graph convex hull layer and pooling layer. The internal process of the graph convex hull layer is as follows: Figure 7 As shown.

[0089] Step 10: The difference between the graph convex hull layer and the traditional convex hull layer is that the input data includes node feature data and graph index data, instead of edge index data. Similar to the convex hull layer, the node feature data is transformed into two-dimensional node feature data through a linear layer. Based on the graph index data, the two-dimensional feature data is divided into a graph node feature set. For each graph, a convex hull is constructed using the same convex hull construction algorithm as the convex hull layer, resulting in a graph convex hull vertex set. The node feature data and graph index data are updated synchronously based on the graph convex hull vertex set, and any remaining node feature data and corresponding graph index data that do not exist in the graph convex hull vertex set are deleted. The updated node feature data and graph index data from the convex hull layer are used as the input data for the pooling layer.

[0090] The above describes the steps for cyclically updating graph data in the message passing layer and convex hull layer. Subsequent iterations will continue based on the layer number parameter. However, the construction of the neighborhood node set will increase cyclically with the layer number parameter. During a k-layer message passing loop, the constructed neighborhood node set will include neighborhood nodes within k hops. Using this process to update graph data enables dynamic aggregation and updating of the convex hull. Each loop updates the edge index data based on the current node's feature data, dynamically adjusting the graph topology and reducing the number of remaining nodes in the neighborhood node set. This enhances the discriminative power of node representation and alleviates the over-smoothing problem caused by repeated aggregation in the message passing loop.

[0091] This invention is not limited to the specific embodiments described above. The specific embodiments described above are merely illustrative and not restrictive. Those skilled in the art can make many modifications under the guidance of this invention without departing from its spirit, and these modifications are all within the protection scope of this invention.

Claims

1. A message-passing graph neural network with dynamic convex hull aggregation, characterized in that, The message-passing graph neural network includes at least two message layers, a ReLU function model, and a fully connected layer; the message layers are connected by convex hull layers that enable dynamic data updates of the neighborhood node set of a single graph between message-passing layers; The convex hull layer includes linear units, neighborhood node units, and the convex hull; wherein, the message-passing graph neural network processes graph data including: Data preprocessing stage: Load single graph data, including initial node feature data and initial edge index data; The message layer uses a message passing paradigm to process the initial node feature data based on the initial edge index data; The convex hull layer reconstructs the dynamic edge index data by building a convex hull vertex set from the node feature data and the initial edge index data. Data loop processing phase: The message layer processes the dynamic edge index data and the node feature data of the previous layer according to the message passing paradigm to obtain the node feature data for this time. The convex hull layer reconstructs the node feature data output by the previous message layer and the initial edge index data according to the convex hull vertex set to obtain dynamic edge index data; The final single graph node feature data is obtained by iterating through the node feature data and dynamic edge index data in all message passing layers and convex hull layers. The ReLU function model and the fully connected layer output trained single-graph node feature data.

2. The message-passing graph neural network with convex hull dynamic aggregation according to claim 1, characterized in that, The process of obtaining dynamic edge index data in the convex hull layer includes: The node feature data output from the message layer is transformed by feature dimension transformation to obtain two-dimensional node feature data; The two-dimensional node feature data is divided into nodes based on the initial edge index data and the message passing layer parameter k. The set of neighboring nodes within k hops; For nodes The set of neighboring nodes is obtained by constructing the convex hull of the nodes using the following formula. The set of convex hull vertices of any neighboring node: ； Among them, nodes The set of neighboring nodes within k hops As input for constructing the convex hull; Update graph data features based on the convex hull vertex set. The neighboring nodes that exist in the convex hull vertex set are the neighboring node set of the nodes in the next message passing layer, and dynamically establish the current edge index data. The node feature data and dynamic edge index data are used for the next layer of message aggregation operations using the following formula: ； in: :node of The set of neighboring nodes within the jump range; :node In the Layer embedding representation; : are non-negative combination coefficients that satisfy the definition conditions of convex hull.

3. A message-passing graph neural network with convex hull dynamic aggregation according to claim 1, characterized in that, The message-passing graph neural network further includes: a graph convex hull layer and a pooling layer; the message layer and the ReLU function model are sequentially connected by a graph convex hull layer and a pooling layer to realize dynamic data updates of the neighborhood node set of multiple graphs between the message-passing layers; the graph convex hull layer includes linear units, graph node units, and a graph convex hull; wherein: The graph convex hull layer constructs a convex hull vertex set from the node feature data output by the previous message layer and the initial graph index data to reconstruct the dynamic graph edge index data and the node feature data of the dynamic graph. The pooling layer performs local region aggregation on the dynamic graph node feature data and dynamic graph edge index data to output multi-graph feature data; The ReLU function model and the fully connected layer output the final multi-graph feature data.

4. A message-passing graph neural network with convex hull dynamic aggregation according to claim 3, characterized in that, The process of obtaining graph index data by the graph convex hull layer includes: Using the node feature data trained through multiple message passing layers and the original graph index data, the node feature data is divided into a graph node feature set. Then, a linear layer is used to transform the feature dimension, resulting in a two-dimensional graph node feature set data, i.e.: ； in: :node Two-dimensional features; :picture The set of node features; For each 2D graph node feature set Construct the convex hull of the graph and obtain the vertex set of the convex hull of each graph. The vertex set of the convex hull of each graph is a subset of the node feature set of the original graph. The set of convex hull vertices of the graph is used as the set of node features of the new graph. The graph index data and node feature data are updated, and node feature data that do not exist in the set of convex hull vertices are deleted. The updated node feature data and graph index data are used as the input of the subsequent pooling layer.

5. A message-passing graph neural network with convex hull dynamic aggregation according to claim 2 or 4, characterized in that, The message layer loads graph data and uses a message passing paradigm to process the edge index data to obtain node feature data. The message passing paradigm is as follows: ； Where UPDATE and AGGREGATE are differentiable aggregate functions. It is a node convex hull vertex set Dynamic graph data aggregated together.

6. A method for dynamic aggregation of the convex hull of a message-passing graph neural network, characterized in that, The method is based on the message-passing graph neural network according to any one of claims 1-2, and includes: Single-image data message propagation process: Step 100: Set a convex hull layer between each message passing layer. Before message passing, use the convex hull layer to reconstruct the neighborhood node set based on the graph data features. The node feature data update adopts a typical message passing paradigm, and its calculation process is shown in formula (1): （1）； Where UPDATE and AGGREGATE are micro-aggregate functions; It is a node convex hull vertex set Aggregated dynamic graph data; Step 200: In the convex hull layer, expand the neighborhood node set according to the message passing layer number, and use a linear layer to perform feature dimension transformation to obtain the convex hull vertex set, which serves as the neighborhood node set of the target node in this message passing layer. Step 201: The graph data includes node feature data and edge index data. All node feature data undergoes feature dimension transformation through a linear layer to obtain two-dimensional node feature data. Step 202: In the In layer propagation, node features are obtained using two-dimensional node feature data. convex hull vertex set to it Within the jump neighborhood nodes Perform an embedding representation and construct its convex hull, i.e.: （2） ； Among them: nodes of Set of neighboring nodes within jump As input for constructing the convex hull, the output is a linear representation of the nodes. The set of convex hull vertices of any neighboring node; Step 203: Update the graph data features based on the convex hull vertex set. The neighboring nodes that exist in the convex hull vertex set are the neighboring node sets of the nodes in the next message passing layer. Dynamically build the current edge index data and add the target node self-loop to obtain dynamic new edge index data. Step 204: Use the updated graph data features for the message aggregation operation at the next layer, as shown in formula (3); （3） ； in: :node of The set of neighboring nodes within the jump range; :node In the Layer embedding representation; : are non-negative combination coefficients that satisfy the definition conditions of convex hull.

7. A method for dynamic aggregation of the convex hull of a message-passing graph neural network, characterized in that, The method is based on the message-passing graph neural network according to any one of claims 3-4, and includes: Multi-image data message propagation process: Step 300: Transform the target object of the convex hull vertex set obtained by constructing the convex hull from the target node into the target graph, and transform the updated edge index data into updated graph index data: Step 301: Using the node feature data trained by the multi-layer message passing layer and the original graph index data, the node feature data is divided into a graph node feature set. Then, a linear layer is used to transform the feature dimension to obtain a two-dimensional graph node feature set, i.e.: ； in: :node Two-dimensional features; :picture The set of node features; Step 302: For each 2D graph node feature set Construct the convex hull of the graph and obtain the vertex set of the convex hull of each graph. The vertex set of the convex hull of each graph is a subset of the node feature set of the original graph. Step 303: Use the set of convex hull vertices of the graph as the new set of graph node features, update the graph index data and node feature data, delete node feature data that does not exist in the set of convex hull vertices of the graph, and use the updated node feature data and graph index data as input to the subsequent pooling layer.

Images