A graph convolutional neural network training method suitable for network edge deployment

Abstract

The application discloses a kind of graph convolutional neural network training methods suitable for network edge deployment, including server division all is multiple subgraphs, after solving joint optimization problem, subgraph and optimization result are issued to edge device;After edge device receives subgraph, broadcast boundary node set;Receive the boundary node set of other equipment, and with internal node intersection sampling generates sampling boundary node set, and is used to reconstruct subgraph;Each edge device combines optimization result and the boundary node feature and gradient information received in last round, and trains reconstructed subgraph, and the boundary node feature and gradient information generated in current round training are transmitted to relevant equipment;Local gradient is uploaded to server by edge device;After server aggregation gradient updates global model parameter and issues;The method is circulated until model converges;The method of the application cooperates training graph convolutional neural network using the computing resource of edge device, reduces communication overhead and frequent synchronization, and significantly reduces system energy consumption.

Description

Technical Field

[0001] This invention relates to the field of network edge computing technology, and in particular to a graph convolutional neural network training method suitable for network edge deployment. Background Technology

[0002] With the rise of artificial intelligence, graph convolutional neural networks (GCNNs) have gained increasing attention from academia and industry. GCNNs have demonstrated superior performance in graph-structured data tasks, such as link prediction, graph classification, and node classification. The success of GCNNs can be attributed to their ability to capture complex adjacency relationships by aggregating features from neighboring nodes and updating the target node features using a multilayer perceptron. This two-step process (neighbor feature aggregation and node feature update) enables GCNNs to learn effectively from graph structures. With the rise of large-scale graph-structured data in the real world, such as social networks like Sina Weibo, WeChat, and Meta, training GCNNs on large-scale graphs has become increasingly important. However, scaling GCNN training to large-scale real-world graph-structured data still faces significant challenges, primarily due to the enormous computational and memory resources required. To address these resource challenges, various sampling-based techniques have been proposed. Neighbor sampling techniques for creating mini-batch data often introduce significant feature approximation errors and sacrifice accuracy. Compared to sampling-based mini-batch construction methods, there are also full-graph training methods utilizing multiple GPUs. Some methods store data on the CPU while utilizing GPU resources for computation; however, this leads to frequent communication between the CPU and GPU during actual training. Other methods store data and perform training on the GPU, but these methods cannot simultaneously address the communication overhead of all boundary nodes during training and the frequent synchronization issues related to obtaining features from boundary nodes. Overall, existing solutions still suffer from the following problems:

[0003] 1. Over-reliance on GPU resources, while the deployment and rental costs of GPU servers are very high, and even when rented through a cloud platform, the cost is still quite expensive.

[0004] 2. Data transfer cost between CPU and GPU: Frequent data transfer between CPU and GPU during data processing leads to reduced efficiency.

[0005] 3. The problem that communication overhead and frequent synchronization issues cannot be solved simultaneously. Summary of the Invention

[0006] In order to overcome the above-mentioned shortcomings and deficiencies of the prior art, the purpose of this invention is to provide a graph convolutional neural network training method suitable for network edge deployment.

[0007] The objective of this invention is achieved through the following technical solution:

[0008] A method for training graph convolutional neural networks suitable for network edge deployment includes the following steps:

[0009] The S1 server divides the entire graph into multiple subgraphs, solves the joint optimization objective of the edge devices regarding the calculation frequency and transmission power to obtain the optimization result, and then sends the subgraphs and optimization results to the edge devices;

[0010] After receiving the subgraph, the S2 edge device broadcasts the obtained set of subgraph boundary nodes to other edge devices;

[0011] S3 calculates and samples the intersection of the internal nodes of the subgraph with the boundary node sets of other subgraphs, generates a sampled boundary node set, and sends the sampled boundary node set to other edge devices;

[0012] S4 Each edge device reconstructs a subgraph based on the received set of sampled boundary nodes. The reconstructed subgraph consists of internal nodes and some boundary nodes.

[0013] Each edge device in S5 trains the reconstructed subgraph based on the optimization results and the forward features and feature gradient information of the sampled boundary node set obtained in the previous round. At the same time, it transmits the forward features and feature gradient information of the sampled boundary node set of the current subgraph to other edge devices.

[0014] Based on the forward features and feature gradient information from the previous round, S6 calculates the local model gradient for each edge device and sends it to the server;

[0015] The S7 server receives and aggregates the local model gradients sent by each edge device, updates the global model parameters, and then sends them back to the edge devices.

[0016] S8 loops through steps S5 to S7 until convergence.

[0017] Furthermore, there are several edge devices. Communication between the server and the edge devices is achieved through downlink and uplink channels, while communication between the edge devices is achieved through point-to-point channels.

[0018] Edge devices collaborate to complete the training task of the graph convolutional neural network by exchanging information at sampling boundary nodes, while the server is responsible for updating the global model parameters using the local model gradients uploaded by the edge devices.

[0019] Furthermore, the server stores the original graph structure data and computing and communication resource information of each edge device, including maximum CPU frequency, maximum transmission power, channel gain, etc.

[0020] Furthermore, in S1, the server divides the entire graph into multiple subgraphs, specifically as follows:

[0021] The server divides the entire graph into K parts with an equal number of internal nodes. Find the first-order neighbors of each node within each part of the entire graph, and use them as boundary nodes. Construct a subgraph by connecting the internal nodes of each part with their corresponding boundary nodes. Where K represents the number of edge devices.

[0022] Furthermore, the joint optimization objective is specifically as follows:

[0023]

[0024]

[0025] Where {f i} refers to the CPU frequency used by the edge device for local computing; τ comp This refers to the local computation allocated to each edge device per round; This refers to the edge device i sending the local model gradient G to the server in each round. i The energy consumed can be expressed as p i The gradient G of the local model from the edge device i-server to the server method. i The transmission power used; This refers to the energy consumed by edge device i in sending the number of sampled boundary nodes to edge device j, which can be expressed as: p i,j This refers to the transmission power used by edge device i to send the sampled boundary node information to edge device j; This refers to assigning the local model gradient G to edge device i. i Communication time given to the server; This refers to the communication time allocated to edge device i to send sampled boundary node information to edge device j; T refers to the total number of iteration rounds; K refers to the number of edge devices; |V| refers to the total number of nodes in the entire graph; a refers to the average number of floating-point operations required to update a node in a subgraph in one iteration; C i This refers to the number of floating-point operations that device i can perform in one CPU cycle; This refers to the capacitance coefficient of device i; B represents the computing power consumption of edge device i; w This refers to the total system bandwidth; c refers to the total communication volume required for weight parameter communication between the edge device and the server in each iteration; q refers to the total communication volume required for sampling boundary node information in each round of communication between edge devices; h i This refers to the uplink channel gain between the edge device i and the server; h i,jThis refers to the point-to-point channel gain between edge device i and edge device j; σ 2 This refers to noise power; τ refers to the total training time limit; f max This refers to the maximum CPU frequency of the device; p max This refers to the maximum communication power of the device.

[0026] Furthermore, it also includes five constraints, specifically:

[0027] Constraint 1 states that the computation time allocated to each edge device in each round is greater than the time any device spends performing local computation in each round; Constraint 2 states that the total amount of communication is greater than the total amount of communication required between the edge device and the server for model gradient updates; Constraint 3 states that the time allocated to edge devices for communication with other edge devices must ensure that the total amount of communication is greater than the total amount of communication between the edge devices and other edge devices for sampling boundary node information; Constraint 4 states that the training time for all iteration rounds is less than the total training time limit; Constraint 5 states that the CPU computation frequency used by each edge device cannot exceed its maximum CPU frequency, and the computation frequency is adjusted through dynamic voltage and frequency adjustment techniques.

[0028] Furthermore, the joint optimization objective is solved using convex optimization techniques to obtain the optimization result {f}. i}、τ comp , Hezi Diagram Send to each edge device, where {f i} refers to the CPU frequency used by edge devices for local computing; τ comp This refers to the allocation of local computation to each edge device per round; This refers to the edge device i sending the local model gradient G to the server in each round. i The energy consumed; This refers to the energy consumed by edge device i in sending the number of sampled boundary nodes to edge device j; This refers to assigning the local model gradient G to edge device i. i Communication time given to the server; This refers to the communication time allocated to edge device i for sending sampled boundary node information to the edge device.

[0029] Furthermore, S3 calculates and samples the intersection of the sets of nodes inside the subgraph and the sets of boundary nodes of other subgraphs to generate a sampled set of boundary nodes, specifically:

[0030] The edge device receives the set of boundary nodes of the subgraph and obtains the intersection of the edge device with the boundary node sets of other subgraphs, constructs an initial sampled boundary node set, and samples the initial sampled boundary node set to obtain the sampled boundary node set.

[0031] Furthermore, each edge device in S5 trains the reconstructed subgraph based on the optimization results, and simultaneously transmits the forward features and feature gradient information obtained from the sampled boundary node set of the current subgraph to other edge devices, specifically:

[0032] The CPU frequency is obtained based on the optimization objective. Training is then performed on the internal nodes of the reconstructed subgraph, and the sampled boundary node set is then processed. Using stale information from the previous iteration, the specific forward pass of the graph convolutional neural network can be described as follows:

[0033]

[0034] Where v is an internal node of the edge device, u is an internal node of the device subgraph among the first-order neighbors of node v, and m is a sampled boundary node of the device subgraph among the first-order neighbors of node v. This indicates that during iteration t, the l-th layer features of node v are used, and the features of this round are applied to the parts belonging to internal nodes. and For the sampled boundary nodes, the features from the previous round are used. After the local iteration is completed, the device sends the node features and feature gradients of the boundary nodes of the subgraphs belonging to other devices and the internal nodes of its own subgraphs to the corresponding devices for use in the next round of calculation.

[0035] Furthermore, the S7 server receives and aggregates the local model gradients sent by each edge device, updates the global model parameters, and then sends them back to the edge devices, specifically as follows:

[0036]

[0037] Among them W t Let η represent the global model parameters in the t-th iteration, and let η represent the learning rate. This represents the model gradient of the i-th subgraph in the t-th iteration.

[0038] Compared with the prior art, the present invention has the following advantages and beneficial effects:

[0039] (1) This invention utilizes the CPU resources of edge devices for collaborative training of graph convolutional neural networks, rather than relying on expensive and scarce GPU resources. This approach reduces the difficulty of implementing large-scale graph convolutional neural network training, making it more applicable and suitable in resource-limited environments, and improving the scalability of resource utilization.

[0040] (2) This invention proposes a joint optimization problem of the computing frequency and transmission power of a device, and effectively reduces energy consumption through reasonable resource allocation.

[0041] (3) This invention employs a method of sampling boundary nodes and using stale boundary node information, which significantly reduces the need for frequent synchronization and communication overhead. This strategy enables collaborative graph neural network training across multiple devices to converge faster than single-device training while maintaining training accuracy. Attached Figure Description

[0042] Figure 1 This is a flowchart of the method of the present invention;

[0043] Figure 2 This is a schematic diagram of the edge network deployment of the present invention;

[0044] Figures 3(a)-3(d) This is a schematic diagram of the server graph partitioning of the present invention;

[0045] Figure 4 This is a simulation graph showing the test set accuracy of the method of the present invention with respect to training time under four edge devices and different numbers of sampling boundary nodes.

[0046] Figure 5 This is a simulation diagram of the system energy consumption of the method of the present invention with respect to the number of edge devices under different numbers of sampling boundary nodes. Detailed Implementation

[0047] The present invention will be further described in detail below with reference to the embodiments, but the implementation of the present invention is not limited thereto.

[0048] Example

[0049] like Figure 1 As shown, a graph convolutional neural network training method suitable for network edge deployment includes the following steps:

[0050] The S1 server divides the entire graph into multiple subgraphs and solves a joint optimization problem of the computing frequency and transmission power of the devices based on the computing and communication resources of the edge devices. Then, it distributes the subgraphs and optimization results to the edge devices.

[0051] In this embodiment, the edge device refers to a terminal device, including computers, mobile phones, etc., which are devices capable of training graph neural networks.

[0052] In this embodiment, "full graph" refers to the entire graph convolution training graph data.

[0053] like Figure 2The diagram shown illustrates the edge network deployment in this embodiment. The system architecture includes a server and several edge devices. Communication between the server and edge devices is achieved through downlink and uplink channels, while communication between edge devices is achieved through point-to-point channels. Edge devices collaborate to complete the training task of the graph convolutional neural network by exchanging information between sampling boundary nodes. The server is responsible for updating the global model parameters using the local model gradients uploaded by the edge devices.

[0054] like Figures 3(a)-3(d) The diagram shown illustrates how the server of this invention divides the entire graph into multiple subgraphs. The server manages the entire graph... Divide the data into K parts with similar numbers of internal nodes. Find all first-order neighbors of the internal node portion in the entire graph as boundary nodes, i.e. Construct a subgraph from the corresponding internal nodes and boundary nodes. Where K represents the number of edge devices, and the number of the partitioned parts is the same as the number of edge devices.

[0055] The server establishes the following optimization objectives based on factors such as the number of internal nodes, the number of sampling boundary nodes, and channel conditions:

[0056]

[0057]

[0058] Where {f i} refers to the CPU frequency used by the edge device for local computing; τ comp This refers to the allocation of local computation to each edge device per round; This refers to the edge device i sending the local model gradient G to the server in each round. i The energy consumed can be expressed as p i The gradient G of the local model from the edge device i-server to the server method. i The transmission power used; This refers to the energy consumed by edge device i in sending the number of sampled boundary nodes to edge device j, which can be expressed as: p i,j This refers to the transmission power used by edge device i to send the sampled boundary node information to edge device j; This refers to assigning the local model gradient G to edge device i. i Communication time given to the server; This refers to the communication time allocated to edge device i to send the sampled boundary node information to the edge device; T refers to the set total number of iteration rounds; K refers to the total number of devices; |V| refers to the total number of nodes in the entire graph; a refers to the average number of floating-point operations required to update a node in a subgraph in one iteration; C i This refers to the number of floating-point operations that device i can perform in one CPU cycle; This refers to the capacitance coefficient of device i; B represents the computing power consumption of edge device i; w This refers to the total system bandwidth; c refers to the total communication volume required for weight parameter communication between the edge device and the server in each iteration; q refers to the total communication volume required for sampling boundary node information in each round of communication between edge devices; h i This refers to the uplink channel gain between the edge device i and the server; h i,j This refers to the point-to-point channel gain between edge device i and edge device j; σ 2 This refers to noise power; τ refers to the total training time limit; f max This refers to the maximum CPU frequency of the device; p max This refers to the maximum communication power of the device. The optimization problem only needs to be solved before formal training, and the optimized solution is sent to the device. The device can then reduce the total training energy consumption by adopting corresponding settings based on the optimized solution during the training process.

[0059] The optimization objective P1 reflects the energy consumption effect of training graph neural networks deployed at the network edge. The smaller the objective function, the less energy is consumed in training the graph neural network and the higher the energy utilization efficiency. To minimize the optimization objective, a trade-off between computational and communication energy consumption needs to be found.

[0060] The optimization objective is subject to five constraints, specifically:

[0061] Constraint 1 states that the computation time allocated to each edge device in each round is greater than the time any device spends on local computation in each round; Constraint 2 states that the total amount of communication is greater than the total amount of communication required between the edge device and the server for model gradient updates; Constraint 3 states that the time allocated to edge devices for communication with other edge devices must ensure that the total amount of communication is greater than the total amount of communication between the edge devices and other edge devices for sampling boundary node information; Constraint 4 states that the training time for all iteration rounds is less than the total training time limit; Constraint 5 states that the CPU computation frequency used by each edge device cannot exceed its maximum CPU frequency, and the computation frequency can be adjusted using Dynamic Voltage and Frequency Scaling (DVFS).

[0062] This embodiment uses convex optimization techniques to solve the joint optimization problem P1. The server will obtain the corresponding optimization result {f}. i}、τ comp , Hezi Diagram Send it to the appropriate edge device.

[0063] Where {f i} refers to the CPU frequency used by edge devices for local computing; τ comp This refers to the allocation of local computation to each edge device per round; This refers to the edge device i sending the local model gradient G to the server in each round. i The energy consumed; This refers to the energy consumed by edge device i in sending the number of sampled boundary nodes to edge device j; This refers to assigning the local model gradient G to edge device i. i Communication time given to the server; This refers to the communication time allocated to edge device i for sending sampled boundary node information to the edge device.

[0064] S2. After receiving the subgraph, the edge device broadcasts the set of boundary nodes of its subgraph to other edge devices in sequence to facilitate the exchange of node information.

[0065] In this embodiment, specifically:

[0066] The edge device receives the subgraph and optimization results sent by the server in step S1, stores them in the storage unit, and sequentially sets the boundary nodes of the obtained subgraph. The broadcast is sent to the other devices so that all devices have the boundary node set of other devices, so that subsequent node information can be exchanged.

[0067] S3. Calculate and sample the intersection of the internal nodes of the subgraph with the boundary node sets of other subgraphs, generate a sampled boundary node set, and send the sampled boundary node set to other edge devices;

[0068] In this embodiment, specifically:

[0069] Each edge device is connected to the set of boundary nodes of the subgraph of the edge devices other than itself in step S2.

[0070] Taking edge device 1 as an example, edge device 1 receives a set of boundary nodes. It is then stored in the storage unit, and the internal nodes of the device subgraph are derived using the computing unit. Boundary nodes of subgraphs with other edge devices The intersection of the points is used to construct the initial set of intersection points. The final set of intersection points is obtained by sampling the initial set of intersection points with an equal number of nodes. This is called the sampling boundary node set, representing the set of sampling boundary nodes that edge device 1 needs to send to device {2,3,…,K} during actual training, and the set of final intersection points after sampling. The message is sent to the corresponding device, and all devices perform the above steps.

[0071] S4. Each edge device reconstructs the subgraph based on the received set of sampled boundary nodes of the subgraph. The reconstructed subgraph consists of internal nodes and some boundary nodes.

[0072] In this embodiment, specifically:

[0073] Each edge device receives the information block from step S3 and, based on the received set of sampled boundary nodes of the subgraph, constructs a new subgraph containing only the device's own internal nodes and the sampled set of boundary nodes, stores it in the storage unit, and deletes the original subgraph in the original storage unit. Taking edge device 1 as an example, upon receiving... Merging to form new boundary nodes for China does not belong to Boundary nodes are removed, thereby reconstructing the subgraph. Right now All devices perform the above steps and can obtain their respective reconstructed subgraphs.

[0074] Based on the optimization results, each edge device in S5 trains the reconstructed subgraph and transmits the forward features and feature gradient information obtained from the sampled boundary node set of the current subgraph to other edge devices.

[0075] In this embodiment, specifically:

[0076] The edge device uses the CPU frequency {f} from the optimization result received in step S2. i}, for internal nodes Training is performed on the sampled set of boundary nodes. Using stale information from the previous iteration, the forward pass of a graph convolutional neural network can be described as follows:

[0077]

[0078] Where v is an internal node of the edge device, u is an internal node of the device subgraph among the first-order neighbors of node v, and m is a sampled boundary node of the device subgraph among the first-order neighbors of node v. This indicates that during iteration t, the l-th layer features of node v are used, and the features of this round are applied to the parts belonging to internal nodes. and For the sampled boundary nodes, the features from the previous round are used. After the local iteration is completed, the device sends the node features and feature gradients of the boundary nodes of the subgraphs belonging to other devices and the internal nodes of its own subgraph to the corresponding devices for use in the next round of calculation. Taking edge device 1 as an example, it sends the features... With feature gradient Give device K.

[0079] Furthermore, the stale information includes dielectric characteristics and characteristic gradients.

[0080] S6. Each edge device uploads the calculated local gradient to the server. In this embodiment, this is specifically done as follows:

[0081] After calculation in step S5, each edge device can obtain the local model gradient in iteration round t. It is sent to the server using the sending unit.

[0082] S7. The server receives and aggregates the model gradients uploaded by each edge device, updates the model parameters, and then sends them back to the edge devices. In this embodiment, this is specifically as follows:

[0083] The server receives a block of information containing local model gradients, aggregates the model gradients of all edge devices, and then updates the model parameters W. t , can be represented as Then W t The parameters are then sent to the edge devices to be used for the next iteration.

[0084] S8. Repeat steps S5 to S7 until convergence. In this embodiment, the specific steps are as follows:

[0085] Repeat steps S5 to S7, and after each iteration, determine whether the training has converged. If it has converged, end the training, output "Training ended" and output the model parameters after the training is completed; otherwise, continue to execute steps S5 to S7.

[0086] Figure 4 The figure shows the simulation results of the test set accuracy of the method of the present invention with respect to training time under four edge devices and different numbers of sampling boundary nodes. As shown in the figure, compared with the centralized training method, the method of the present invention not only maintains the accuracy of centralized training, but also improves the convergence speed, and the effect is more obvious when the number of sampling boundary nodes is smaller.

[0087] Figure 5 The figure shows the simulation results of the system energy consumption of the method of the present invention with respect to the number of edge devices under different numbers of sampling boundary nodes. As shown in the figure, compared with the centralized training method, the method of the present invention consumes less system energy under different numbers of devices, and the effect is more obvious when the number of sampling boundary nodes is smaller.

[0088] The above embodiments are preferred embodiments of the present invention, but the embodiments of the present invention are not limited to the embodiments described above. Any changes, modifications, substitutions, combinations, or simplifications made without departing from the spirit and principle of the present invention shall be considered equivalent substitutions and shall be included within the protection scope of the present invention.

Claims

1. A training method for graph convolutional neural networks suitable for network edge deployment, characterized in that, Includes the following steps: The S1 server divides the entire graph into multiple subgraphs, solves the joint optimization objective of the edge devices regarding the calculation frequency and transmission power to obtain the optimization result, and then sends the subgraphs and optimization results to the edge devices; The joint optimization objective is specifically as follows: Where {f i } refers to the CPU frequency used by edge device i in local computing; τ comp This refers to the local computation allocated to each edge device per round; This refers to the edge device i sending local model gradients G to the server in each round. i The energy consumed; This refers to the energy consumed by edge device i in sending the number of sampled boundary nodes to edge device j; This refers to assigning the local model gradient G to edge device i. i Communication time given to the server; This refers to the communication time allocated to edge device i to send sampled boundary node information to edge device j; T refers to the total number of iteration rounds; K refers to the number of edge devices; |V| refers to the total number of nodes in the entire graph; a refers to the average number of floating-point operations required to update a node in a subgraph in one iteration; C i This refers to the number of floating-point operations that edge device i can perform in one CPU cycle; This refers to the capacitance coefficient of device i; B represents the computing power consumption of edge device i; w This refers to the total system bandwidth; c refers to the total communication volume required for each iteration of the edge device to communicate weight parameters with the server; q refers to the total communication volume required for each round of communication between the edge devices to sample boundary node information; h refers to the total communication volume required for each round of communication between the edge devices. i This refers to the uplink channel gain between the edge device i and the server; h i,j This refers to the point-to-point channel gain between edge device i and edge device j; σ 2 This refers to noise power; τ refers to the total training time limit; f max This refers to the maximum CPU frequency of the device; p max This refers to the maximum communication power of the device; After receiving the subgraph, the S2 edge device broadcasts the obtained set of subgraph boundary nodes to other edge devices; S3 calculates and samples the intersection of the internal nodes of the subgraph with the boundary node sets of other subgraphs, generates a sampled boundary node set, and sends the sampled boundary node set to other edge devices; Each edge device in S4 reconstructs a subgraph based on the received set of sampled boundary nodes. The reconstructed subgraph consists of internal nodes and some boundary nodes. Based on the optimization results, each edge device in S5 trains the reconstructed subgraph and transmits the forward features and feature gradient information obtained from the sampled boundary node set of the current subgraph to other edge devices. Based on the forward features and feature gradient information from the previous round, S6 calculates the local model gradient for each edge device and sends it to the server; The S7 server receives and aggregates the local model gradients sent by each edge device, updates the global model parameters, and then sends them back to the edge devices. S8 loops through steps S5 to S7 until convergence.

2. The graph convolutional neural network training method according to claim 1, characterized in that, The edge devices consist of several units. Communication between the server and the edge devices is achieved through downlink and uplink channels, while communication between the edge devices is achieved through point-to-point channels. Edge devices collaborate to complete the training task of graph convolutional neural networks through information exchange at boundary nodes, while the server is responsible for updating global model parameters using the local model gradients uploaded by the edge devices.

3. The graph convolutional neural network training method according to claim 1, characterized in that, The computing frequency and transmission power of edge devices include maximum CPU frequency, maximum transmission power, and channel gain.

4. The graph convolutional neural network training method according to claim 1, characterized in that, In S1, the server divides the entire graph into multiple subgraphs, specifically: The server divides the entire graph into K parts with an equal number of internal nodes. Find the first-order neighbors of each node within each part of the entire graph, and use them as boundary nodes. Construct a subgraph by connecting the internal nodes of each part with their corresponding boundary nodes. Where K represents the number of edge devices.

5. The graph convolutional neural network training method according to claim 1, characterized in that, It also includes five constraints, specifically: Constraint 1 states that the computation time allocated to each edge device in each round is greater than the time any device spends performing local computation in each round; Constraint 2 states that the total amount of communication is greater than the total amount of communication required between the edge device and the server for model gradient updates; Constraint 3 states that the time allocated to edge devices for communication with other edge devices must ensure that the total amount of communication is greater than the total amount of communication between the edge devices and other edge devices for sampling boundary node information; Constraint 4 states that the training time for all iteration rounds is less than the total training time limit; Constraint 5 states that the CPU computation frequency used by each edge device cannot exceed its maximum CPU frequency, and the computation frequency is adjusted through dynamic voltage and frequency adjustment techniques.

6. The graph convolutional neural network training method according to claim 5, characterized in that, The joint optimization objective is solved using convex optimization techniques to obtain the optimization results. Hezi Diagram Send to each edge device.

7. The graph convolutional neural network training method according to claim 1, characterized in that, S3 calculates and samples the intersection of the sets of nodes inside the subgraph and the sets of nodes on the boundaries of other subgraphs, generating a sampled set of boundary nodes, specifically: The edge device receives the set of boundary nodes of the subgraph and obtains the intersection of the edge device with the boundary node sets of other subgraphs, constructs an initial sampled boundary node set, and samples the initial sampled boundary node set to obtain the sampled boundary node set.

8. The graph convolutional neural network training method according to claim 1, characterized in that, Each edge device in S5 trains the reconstructed subgraph based on the optimization results, and simultaneously transmits the forward features and feature gradient information obtained from the sampled boundary node set of the current subgraph to other edge devices, specifically: The CPU frequency is obtained based on the optimization objective. Training is then performed on the internal nodes of the reconstructed subgraph, and the sampled boundary node set is then processed. Using stale information from the previous iteration, the specific forward pass of the graph convolutional neural network can be described as follows: Where v is an internal node of the edge device, u is an internal node of the device subgraph among the first-order neighbors of node v, and m is a sampled boundary node of the device subgraph among the first-order neighbors of node v. This indicates that during iteration t, the l-th layer features of node v are used, and the features of this round are applied to the parts belonging to internal nodes. and For the sampled boundary nodes, the features from the previous round are used. After the local iteration is completed, the device sends the node features and feature gradients of the boundary nodes of the subgraphs belonging to other devices and the internal nodes of its own subgraphs to the corresponding devices for use in the next round of calculation.

9. The graph convolutional neural network training method according to any one of claims 1-8, characterized in that, The S7 server receives and aggregates the local model gradients sent by each edge device, updates the global model parameters, and then sends them back to the edge devices. Specifically: Among them W t Let η represent the global model parameters in the t-th iteration, and let η represent the learning rate. This represents the model gradient of the i-th subgraph in the t-th iteration.

Images