Model data processing method and device, storage medium and electronic equipment

Abstract

The invention discloses a model data processing method and device, a storage medium and electronic equipment. The method comprises the following steps: in response to a model training request sent by a server, training based on local training data and initial model parameters to obtain local model parameters and link state information, and sending the link state information to the server; the maximum communication loop determined by the server according to the link state information is received, the maximum communication loop represents a communication path in which the number of times of passing through each client in the M clients meets a preset number of times condition and the value of M is the maximum, and M is a positive integer; and according to the maximum communication loop, acquiring local model parameters corresponding to other clients except the client in sequence, and aggregating the local model parameters to generate global model parameters. The technical problem that the model training efficiency is difficult to guarantee due to unstable communication between the client and the server is solved.

Description

TECHNICAL FIELD

[0001] The present application relates to the field of computers, and in particular, to a model data processing method and device, a storage medium and an electronic device. BACKGROUND

[0002] As a core component of global communication infrastructure, the low-orbit satellite constellation of satellite internet accumulates a large amount of user location, communication traffic and satellite state data through multi-satellite networking. These data have important value for promoting the intelligent transformation of satellite internet, but need to be intelligently processed on the premise of ensuring data privacy and security. The federated learning technology is introduced into this field, allowing multiple satellite clients to collaboratively train artificial intelligence models without sharing raw data.

[0003] The related art generally adopts a centralized federated learning framework: after the satellite as a client trains the model using local data, the local model parameters are uploaded to the ground center server for aggregation, a global model is generated and then distributed to each satellite. This architecture has significant defects: first, a large amount of model parameters are concentrated in a short time to a single center node, which easily causes network congestion and exceeds the bandwidth limit of the satellite-ground link; second, limited by the short communication window between the satellite and the ground station, a large amount of time is spent waiting for all satellites to complete model uploading; finally, the center server has a single point of failure risk, and once it fails, the entire training will be interrupted. Although some improved solutions attempt to optimize efficiency through hierarchical aggregation or asynchronous mechanisms, they still cannot solve the problem of intermittent interruption of inter-satellite links caused by the high-speed movement of satellites, resulting in unreliable model interaction and aggregation process.

[0004] Therefore, the low-orbit satellite constellation federated learning has the technical problem that due to the dynamic instability of the inter-satellite link, the training efficiency of the model parameters is difficult to guarantee.

[0005] At present, no effective solution has been proposed to solve the above problems. SUMMARY

[0006] The embodiments of the present application provide a model data processing method and device, a storage medium and an electronic device to at least solve the technical problem that unstable communication between the client and the server leads to difficulty in guaranteeing the efficiency of model training.

[0007] According to one aspect of an embodiment of the present application, a method for processing model data is provided, comprising: responding to a model training request sent by a server, performing training based on local training data and initial model parameters to obtain local model parameters and link status information, and sending the link status information to the server, wherein the model training request includes the initial model parameters; receiving a maximum communication loop determined by the server based on the link status information, wherein the maximum communication loop represents a communication path in which the number of times passing through each of M clients meets a preset number condition and M has the largest value, where M is a positive integer; obtaining the local model parameters corresponding to other clients except itself in turn according to the maximum communication loop, performing aggregation, and generating global model parameters.

[0008] According to another aspect of an embodiment of the present application, a method for processing model data is provided, comprising: sending a model training request to a client, the model training request including initial model parameters; receiving link status information sent by the client, wherein the link status information represents information obtained by the client through training based on the local training data and the initial model parameters; determining a maximum communication loop based on the link status information, wherein the maximum communication loop represents a communication path in which the number of times passing through each of M clients satisfies a preset number condition and M has the largest value, where M is a positive integer; receiving global model parameters uploaded by the client, wherein the global model parameters represent model parameters generated by the client by aggregating the local model parameters corresponding to other clients except itself obtained in sequence according to the maximum communication loop.

[0009] According to another aspect of the embodiment of the present application, a model data processing device is also provided, including: a training module, used to respond to a model training request sent by a server, perform training based on local training data and initial model parameters, obtain local model parameters and link status information, and send the link status information to the server, wherein the model training request includes the initial model parameters; a first receiving module, used to receive the maximum communication loop determined by the server according to the link status information, wherein the maximum communication loop represents a communication path in which the number of times passing through each of M clients meets a preset number condition and M has the largest value, and M is a positive integer; a generation module, used to obtain the local model parameters corresponding to other clients except itself in turn according to the maximum communication loop, aggregate them, and generate global model parameters.

[0010] In an example embodiment, the apparatus is configured to aggregate the local model parameters of other clients except itself in sequence according to the maximum communication loop to generate the global model parameters by: dividing the local model parameters into M blocks based on the number of clients in the maximum communication loop; and performing distributed accumulation and synchronization for the M blocks in sequence according to the maximum communication loop to generate the global model parameters.

[0011] In an example embodiment, the apparatus is configured to generate the global model parameters by performing distributed accumulation and synchronization for the M blocks in sequence according to the maximum communication loop by: summing the blocks sent by the previous client and the blocks of itself based on the maximum communication loop in sequence, and sending the updated blocks to the next client, repeating M-1 times to obtain intermediate model parameters; and replacing the intermediate model parameters stored by itself with the intermediate model parameters sent by the previous client based on the maximum communication loop, repeating M-1 times to generate the global model parameters.

[0012] In an example embodiment, the apparatus is further configured to: determine a model metric parameter threshold based on the model training request; determine a current model metric parameter after training based on the local training data and the initial model parameters; determine whether to end the training based on a comparison result of the model metric parameter threshold and the current model metric parameter; and send the global model parameters to the server in a case where it is determined that the training needs to be ended.

[0013] According to another aspect of the embodiments of the present application, a model data processing apparatus is provided, which comprises: a sending module configured to send a model training request to a client, the model training request comprising initial model parameters; a second receiving module configured to receive link state information sent by the client, wherein the link state information represents information obtained by the client based on the local training data and the initial model parameters; a determining module configured to determine a maximum communication loop based on the link state information, wherein the maximum communication loop represents a communication path with the largest value of M, which satisfies a preset number of times condition, and M represents the number of times through each client in the M clients, M being a positive integer; and a third receiving module configured to receive global model parameters uploaded by the client, wherein the global model parameters represent model parameters generated by the client by aggregating local model parameters of other clients except itself in sequence according to the maximum communication loop.

[0014] In one exemplary embodiment, the apparatus is configured to determine the maximum communication loop based on the link state information by: constructing a network topology graph based on a predetermined set of clients; determining connection states between clients in the network topology graph based on the link state information; and determining the maximum communication loop according to the network topology graph and the connection states.

[0015] In one exemplary embodiment, the apparatus is configured to determine the maximum communication loop based on the link state information by: randomly selecting a client from the network topology graph as an initial node and constructing a path record structure; recursively exploring each unvisited neighbor node from the initial node based on the link state information, each explored neighbor node being considered as a current node; determining whether the current node satisfies a termination condition by marking the current node as visited and adding the current node to an end of the path record structure; in the case that the current node does not satisfy the termination condition, reselecting a node marked as unvisited from neighboring nodes of the current node as the current node for reexploration until traversal is completed; and in the case that the current node satisfies the termination condition, generating the maximum communication loop.

[0016] In one exemplary embodiment, the apparatus is configured to determine whether the current node satisfies a termination condition by marking the current node as visited and adding the current node to an end of the path record structure by: in the case that a total number of nodes in the path record structure is equal to a total number of nodes of the network topology graph and a head node coincides with a tail node, generating a valid loop; and in the case that a length of the valid loop exceeds a historical maximum value, determining that the termination condition is satisfied and updating the valid loop as the maximum communication loop; wherein, when neighboring nodes of the current node are all marked as the visited state or the valid loop is not found, removing the current node from the end of the path record structure and resetting a visited state of the current node.

[0017] In an example embodiment, the device is configured to determine whether the current node satisfies a termination condition by marking the current node as visited and adding the current node to an end of the path record structure, in a manner that: in a case where a total number of nodes in the path record structure is equal to a total number of nodes of the network topology graph and a head node coincides with a tail node, an effective loop is generated; in a case where a length of the effective loop exceeds a historical maximum value, a sum of weights of edges in the effective loop is determined, wherein the weights of the edges are used to indicate communication rates of the edges; in a case where the sum of the weights of the edges in the effective loop exceeds the historical maximum value, it is determined that the termination condition is satisfied, and the effective loop is updated as the maximum communication loop; and in a case where all neighboring nodes of the current node are marked as the visited or the effective loop is not found, the current node is removed from the end of the path record structure and the visited state of the current node is reset.

[0018] According to another aspect of the embodiments of the present application, a computer readable storage medium is provided, and the computer readable storage medium stores a computer program. The computer program is configured to perform the above method for processing model data when executed.

[0019] According to another aspect of the embodiments of the present application, a computer program product or a computer program is provided, and the computer program product or the computer program includes computer instructions stored in a computer readable storage medium. A processor of a computer device reads the computer instructions from the computer readable storage medium, and the processor executes the computer instructions to enable the computer device to perform the above method for processing model data.

[0020] According to another aspect of the embodiments of the present application, an electronic device is provided, and the electronic device includes a memory and a processor. The memory stores a computer program, and the processor is configured to perform the above method for processing model data by using the computer program.

[0021] In the embodiments of the present application, a client local training and a link state reporting mechanism are adopted, and a decentralized interaction strategy of dynamically constructing a maximum communication loop by a server is adopted, so that the purpose of efficiently adapting to dynamic changes of inter-satellite links is achieved, and the technical effect of greatly improving the reliability of federated learning model aggregation is achieved, and thus the technical problem that communication instability between a client and a server causes the efficiency of model training to be difficult to guarantee is solved. BRIEF DESCRIPTION OF DRAWINGS

[0022] The accompanying drawings, which are included to provide a further understanding of the present application and are incorporated in and constitute a part of this application, illustrate embodiments of the present application and serve to explain the present application. In the drawings:

[0023] Figure 1 is a schematic diagram of an application environment of an optional model data processing method according to an embodiment of the present application;

[0024] Figure 2 is a flowchart of an optional method for processing model data according to an embodiment of the present application;

[0025] Figure 3 is a schematic diagram of an optional method for processing model data according to an embodiment of the present application;

[0026] Figure 4 is a schematic diagram of another optional method for processing model data according to an embodiment of the present application;

[0027] Figure 5 is a schematic diagram of another optional method for processing model data according to an embodiment of the present application;

[0028] Figure 6 is a schematic diagram of another optional method for processing model data according to an embodiment of the present application;

[0029] Figure 7 is a schematic diagram of another optional method for processing model data according to an embodiment of the present application;

[0030] Figure 8 is a schematic diagram of another optional method for processing model data according to an embodiment of the present application;

[0031] Figure 9 is a schematic diagram of another optional method for processing model data according to an embodiment of the present application;

[0032] Figure 10 is a schematic diagram of another optional method for processing model data according to an embodiment of the present application;

[0033] Figure 11 is a schematic diagram of another optional method for processing model data according to an embodiment of the present application;

[0034] Figure 12 is a schematic diagram of another optional method for processing model data according to an embodiment of the present application;

[0035] Figure 13 is a schematic diagram of another optional method for processing model data according to an embodiment of the present application;

[0036] Figure 14 is a schematic diagram of another optional method for processing model data according to an embodiment of the present application;

[0037] Figure 15is a schematic diagram of another optional method for processing model data according to an embodiment of the present application;

[0038] Figure 16 is a schematic diagram of another optional method for processing model data according to an embodiment of the present application;

[0039] Figure 17 is a schematic diagram of another optional method for processing model data according to an embodiment of the present application;

[0040] Figure 18 is a schematic diagram of another optional method for processing model data according to an embodiment of the present application;

[0041] Figure 19 is a schematic structural diagram of an optional model data processing device according to an embodiment of the present application;

[0042] Figure 20 It is a structural diagram of another optional model data processing device according to an embodiment of the present application. DETAILED DESCRIPTION

[0043] In order to enable those skilled in the art to better understand the present invention, the following will clearly and completely describe the technical solutions in the embodiments of the present invention in conjunction with the drawings in the embodiments of the present invention. Obviously, the described embodiments are only part of the embodiments of the present invention, not all of the embodiments. Based on the embodiments in the present invention, all other embodiments obtained by ordinary technicians in this field without making creative efforts should fall within the scope of protection of this application.

[0044] It should be noted that the terms "first", "second", etc. in the specification and claims of the present application and the above-mentioned drawings are used to distinguish similar objects and are not necessarily used to describe a specific order or sequential order. It should be understood that the data used in this way can be interchangeable where appropriate, so that the embodiments of the present application described herein can be implemented in an order other than those illustrated or described herein. In addition, the terms "including" and "having" and any variations thereof are intended to cover non-exclusive inclusions, for example, a process, method, system, product or device comprising a series of steps or units is not necessarily limited to those steps or units clearly listed, but may include other steps or units that are not clearly listed or inherent to these processes, methods, products or devices.

[0045] First, some nouns or terms that appear in the description of the embodiments of the present application are subject to the following interpretations:

[0046] Federated learning: It is a collaborative machine learning framework in which multiple clients train model parameters locally and upload them to a server for aggregation.

[0047] The present application will be described below with reference to the following embodiments:

[0048] According to one aspect of an embodiment of the present application, a method for processing model data is provided. Optionally, in this embodiment, the method for processing model data can be applied to Figure 1 In the hardware environment composed of the server 101 and the terminal device 103 shown in FIG. Figure 1 As shown, the server 101 is connected to the terminal device 103 via a network and can be used to provide services for the terminal device or the application 107 installed on the terminal device. The application can be a video application, instant messaging application, browser application, educational application, game application, etc. A database 105 may be set up on the server or independently of the server to provide data storage services for the server 101, for example, a game data storage server. The above-mentioned network may include but is not limited to: a wired network, a wireless network, wherein the wired network includes: a local area network, a metropolitan area network and a wide area network, and the wireless network includes: Bluetooth, WIFI and other networks that implement wireless communication. The terminal device 103 may be a terminal configured with an application, and may include but is not limited to at least one of the following: a mobile phone (such as an Android phone, an iOS phone, etc.), a laptop computer, a tablet computer, a PDA, a MID (Mobile Internet Devices), a PAD, a desktop computer, a smart TV, an intelligent voice interaction device, a smart home appliance, a vehicle-mounted terminal, an aircraft, a virtual reality (VR) terminal, an augmented reality (AR) terminal, a mixed reality (MR) terminal and other computer devices. The above-mentioned server may be a single server, a server cluster consisting of multiple servers, or a cloud server.

[0049] Combine Figure 1 As shown, the above-mentioned model data processing method can be executed by an electronic device, which can be a terminal device or a server. The above-mentioned model data processing method can be implemented by the terminal device or the server separately, or by the terminal device and the server together.

[0050] The above is only an example and is not specifically limited in this embodiment.

[0051] Alternatively, as an optional implementation, Figure 2 As shown, taking the terminal device (i.e., the client) as the execution subject as an example, the processing method of the above model data includes:

[0052] S202, in response to a model training request sent by the server, performing training based on local training data and initial model parameters, obtaining local model parameters and link state information, and sending the link state information to the server, wherein the model training request includes the initial model parameters;

[0053] S204, receiving a maximum communication loop determined by the server based on the link state information, where the maximum communication loop represents a communication path that passes through each of the M clients a number of times that satisfies a preset number condition and where M is a maximum value, where M is a positive integer;

[0054] S206: Obtain local model parameters corresponding to other clients except the client itself in sequence according to the maximum communication loop to generate global model parameters.

[0055] Alternatively, as an optional implementation, Figure 3 As shown, taking the server as the execution subject as an example, the processing method of the above model data includes:

[0056] S302, sending a model training request to the client, where the model training request includes initial model parameters;

[0057] S304, receiving link state information sent by the client, where the link state information represents information obtained by the client through training based on local training data and initial model parameters;

[0058] S306, determining a maximum communication loop based on the link state information, where the maximum communication loop represents a communication path that passes through each of the M clients a number of times that satisfies a preset number condition and where M has a maximum value, where M is a positive integer;

[0059] S308 , receiving global model parameters uploaded by the client, wherein the global model parameters refer to model parameters generated by aggregating local model parameters corresponding to other clients except itself obtained in sequence according to the maximum communication loop.

[0060] Optionally, in an embodiment of the present application, the above-mentioned model training request may include but is not limited to a distributed training instruction initiated by the server to the client, which includes initialization of global model parameters and training configuration information. For example, in a satellite constellation scenario, the ground server sends a request packet containing the initial weights of the Long Short-Term Memory neural network (LSTM neural network) to the selected satellite node, along with constraints such as the upper limit of training rounds and the convergence threshold. This includes but is not limited to the model training trigger mechanism of the Network Data Analytics Function (NWDAF) network element in the 3rd Generation Partnership Project (3GPP standard), or the parameter pre-configuration scenario of the satellite orbit calculation model.

[0061] Optionally, in an embodiment of the present application, the link status information may include, but is not limited to, a data set characterizing the real-time performance of the inter-satellite communication link, covering dynamic indicators such as link connectivity, transmission delay, and bandwidth availability. For example, a satellite periodically reports the ISL (inter-satellite link) signal-to-noise ratio, bit error rate, and available time window with adjacent nodes within / between the orbital plane. This may include, but is not limited to, a link quality matrix based on the Time Division Multiple Access (TDMA) mechanism, or link stability assessment data that takes into account Doppler shift compensation.

[0062] Optionally, in an embodiment of the present application, the maximum communication loop may include, but is not limited to, a one-way communication path covering the most nodes constructed in a satellite network topology, where each node is visited only once. For example, a depth-first search algorithm is used to generate a loop of seven nodes, namely, satellite node 1 → satellite node 2 → satellite node 3 → satellite node 4 → satellite node 5 → satellite node 6 → node 7, in a constellation of nine satellites. This includes, but is not limited to, a weighted longest path that takes into account link weights, or a redundant loop topology that supports fault tolerance.

[0063] Optionally, in embodiments of the present application, the global model parameters may include, but are not limited to, global model parameters obtained by aggregating other client model data sets obtained through decentralized interactions. For example, satellite node 1 sequentially receives model blocks from satellite nodes 2, 3, and 4 via the Ring AllReduce protocol, reconstructs the pre-aggregation parameter matrix, and then aggregates the resulting global model parameters. The pre-aggregation parameter matrix may include, but is not limited to, gradient tensor slices or partitioned segments of the model weight vector.

[0064] In an exemplary embodiment, when a satellite client (e.g., a low-orbit satellite deploying a network data analytics function (NWDAF)) receives a model training request issued by a ground server, it first parses the initial model parameters (e.g., convolutional neural network weight matrices) in the request. Then, it performs forward propagation and back propagation calculations using locally stored sensor data (e.g., multispectral images collected by the satellite payload) to generate updated local model parameters. At the same time, it monitors the inter-satellite link status of neighboring satellites in the orbit (e.g., signal-to-noise ratio fluctuations in the Ku-Archaic band (Ka band) link) and encapsulates the trained local model evaluation indicators (e.g., loss function values) and link quality data into a status report, which is transmitted to the ground server through a directional antenna.

[0065] After the server integrates all the link status information reported by the satellites, it constructs a weighted topology graph with satellites as vertices and available links as edges. It uses graph theory algorithms (e.g., an improved depth-first search (DFS)) to solve a single-loop path that covers the most nodes, ensuring that the loop length is maximized and that no node is visited repeatedly. The loop must satisfy predetermined physical constraints, and the final loop node sequence is broadcast to the constellation network.

[0066] Based on the received loop path information, the satellite clients start model parameter exchange in a predetermined order (e.g., clockwise). They use a block transmission mechanism to split the local model parameters into M data blocks (M is the number of loop nodes), send the specified block to the next node through the inter-satellite laser link, and receive the block data from the previous node. After M-1 rounds of iterative exchange, each client obtains the complete model parameter set of all other clients.

[0067] The clients perform aggregation operations on the local model parameters and the obtained external parameters, typical schemes including weighted averaging (e.g., assigning weights according to data volume) or gradient fusion. The aggregated global model parameters are updated synchronously to the local model library for the next round of training or real-time inference.

[0068] It should be noted that the communication topology construction can use various optimization strategies: in the topology dimension, it can be expanded to a multi-loop parallel structure (e.g., dividing into sub-loops according to the orbital plane); in the link evaluation dimension, it can introduce reinforcement learning to dynamically adjust the weight coefficients (e.g., preferentially selecting low-elevation links); in the aggregation algorithm dimension, it can support hierarchical aggregation mechanisms other than federated averaging (e.g., first aggregating within the orbital plane and then fusing across planes). Changes to the above implementation methods are within the scope of protection of the present scheme, and this application does not specifically limit them.

[0069] Through the embodiments of the present application, a client-side local training and link status reporting mechanism is adopted, and a decentralized interaction strategy of dynamically building a maximum communication loop through the server is used to achieve the purpose of efficiently adapting to the dynamic changes of inter-satellite links, thereby achieving the technical effect of a leap in the aggregation reliability of the federated learning model, and further solving the technical problem of unstable communication between the client and the server, which makes it difficult to ensure the efficiency of model training.

[0070] As an optional solution, local model parameters corresponding to other clients except the client itself are obtained in sequence according to the maximum communication loop to generate global model parameters, including:

[0071] Divide the local model parameters into M blocks based on the number of clients in the maximum communication loop;

[0072] According to the maximum communication loop, distributed accumulation and synchronization are performed on M blocks in turn to generate global model parameters.

[0073] Optionally, in an embodiment of the present application, the above-mentioned block partitioning may include, but is not limited to, splitting the local model parameters into multiple data subsets by dimension. For example, splitting a neural network weight matrix containing 1 million parameters into 8 equal sub-matrices by row, including but not limited to weighted partitioning based on parameter importance or cutting by convolution kernel group.

[0074] Optionally, in embodiments of the present application, the distributed accumulation may include, but is not limited to, step-by-step aggregation calculations performed on an intersatellite communication loop. For example, while satellite node A sends its second block to satellite node B, it receives the first block from satellite node C and adds it to the corresponding local block, including, but not limited to, gradient accumulation or weight fusion operations.

[0075] Optionally, in embodiments of the present application, the aforementioned full synchronization may include, but is not limited to, ultimately enabling all nodes to obtain a complete global model state. For example, after M-1 rounds of interaction, each satellite possesses all model blocks of other satellites, including but not limited to a final synchronization verification mechanism based on broadcast.

[0076] In an exemplary embodiment, the satellite client performs the following model parameter synchronization operations:

[0077] S1, block division stage: parse the model parameters generated by local training (such as a 100MB residual network (ResNet) weight file); divide the parameters into M blocks according to the maximum number of communication loop nodes M;

[0078] S2, distributed accumulation phase (Scatter-Reduce): multiple rounds of transmission are initiated in a loop sequence. In each round of transmission, the block with the specified sequence number is sent to the next node, and the block sent by the previous node is received at the same time. The accumulation operation is performed immediately after receiving the block.

[0079] S3, All-Gather: After the accumulation is completed, the M-1 round of data exchange is started; accumulation is not performed during transmission, and the target block is directly replaced;

[0080] S4, target parameter generation: after completing the all-gather phase, all blocks are reorganized;

[0081] Example: A navigation satellite stitches the reassembled blocks together in sequence to form a parameter set containing the training results of all satellites.

[0082] It should be noted that the synchronization mechanism has multiple implementation variations: non-uniform partitioning can be supported in the block partitioning dimension; parallel pipelines can be adopted in the transmission protocol dimension; and tree aggregation can be used in the aggregation algorithm dimension. All variations of the above implementations fall within the scope of protection of this solution and are not specifically limited in this application.

[0083] Through the embodiments of this application, block transmission avoids the need for single large file transfers, adapts to intersatellite link bandwidth limitations, and requires only partial data retransmission (approximately 1 / M of the total) in the event of a single block transmission failure. Accumulation operations are distributed to multiple nodes for execution, alleviating computing pressure on a single satellite. Ring pipeline transmission makes synchronization time linear rather than exponential with the number of nodes. This significantly improves the practicality of federated learning for low-orbit satellites and provides a technical foundation for key tasks such as real-time updates of space target recognition models and global weather forecast models on board. Compared to traditional centralized aggregation, the communication load is significantly reduced, while also improving the task completion rate in highly dynamic link environments.

[0084] As an optional solution, distributed accumulation and synchronization are performed on M blocks in sequence according to the maximum communication loop to generate global model parameters, including:

[0085] Based on the maximum communication loop, the block received from the previous client is summed with its own block, and the updated block is sent to the next client. This is repeated M-1 times to obtain the intermediate model parameters.

[0086] Based on the maximum communication loop, the intermediate model parameters received from the previous client are used to replace the intermediate model parameters stored in the system. This is repeated M-1 times to generate the global model parameters.

[0087] Optionally, in embodiments of the present application, the above-mentioned distributed accumulation can include but is not limited to parameter aggregation operations performed step by step on inter-satellite ring links. For example, a satellite adds received neighbor model blocks with local corresponding blocks element by element, including but not limited to gradient tensor accumulation or weight matrix summation.

[0088] Optionally, in embodiments of the present application, the above-mentioned intermediate model parameters can include but are not limited to transitional model data that completes partial aggregation. For example, block combinations formed after multiple rounds of accumulation, including but not limited to temporary parameter snapshots marked with version.

[0089] Optionally, in embodiments of the present application, the above-mentioned parameter replacement can include but is not limited to operations of directly covering local data in the synchronization phase. For example, a satellite replaces local corresponding block copies with received complete block data, including but not limited to atomic replacement mechanisms with checks.

[0090] In an exemplary embodiment, a satellite client performs the following two-phase synchronization operation:

[0091] Phase 1: Scatter-Reduce:

[0092] Operation flow:

[0093] S1, start transmission in loop order.

[0094] S2, each satellite performs: receive a specified sequence number block sent by a predecessor node; sum the received block with a local corresponding block element by element; send the updated block to a successor node.

[0095] S3, repeat M-1 rounds (M is the number of loop nodes).

[0096] Phase 2: All-Gather:

[0097] Operation flow:

[0098] S1, keep the same loop transmission order;

[0099] S2, each satellite performs: receive a complete block sent by a predecessor node; directly replace the local corresponding block (without performing calculation); forward the new block to a successor node.

[0100] S3, repeat M-1 rounds.

[0101] It should be noted that the mechanism has multiple dimensions of optimization space: in the block division dimension, dynamic block division can be supported (such as adjusting the block size according to the satellite storage margin); in the transmission order dimension, it can be optimized to a bidirectional pipeline (simultaneous transmission and reception of different sequence number blocks); in the aggregation algorithm dimension, it can be fused with sparse processing (only important gradients are transmitted). The changes of the above embodiments are within the protection scope of the present scheme, and the present application does not specifically limit this.

[0102] Through the embodiments of the present application, single-star instantaneous computing power overload is avoided, block pipeline transmission significantly improves bandwidth utilization, intermediate parameters only need to store single-block data, reducing the demand for on-board memory, and single-round transmission failure only needs to retransmit a single block (about 1 / M data amount), realizing efficient parameter synchronization of low-orbit satellite federated learning, significantly shortening the time consumption of model aggregation of node constellation, providing core technical support for tasks such as real-time updating of earth observation models and space weather warning models on the satellite.

[0103] As an optional solution, the above method further comprises:

[0104] determining a model metric parameter threshold based on the model training request;

[0105] determining a current model metric parameter after training based on the local training data and the initial model parameter;

[0106] determining whether to end the training based on a comparison result of the model metric parameter threshold and the current model metric parameter;

[0107] in the case of determining that the training needs to be ended, sending the global model parameter to the server.

[0108] Optionally, in the embodiments of the present application, the model metric parameter threshold can include but is not limited to a quantitative standard for judging the convergence of the model training, and the setting needs to consider the task demand and resource constraint. The current model metric parameter can include but is not limited to the real-time performance index of the local model after this round of training. The comparison result can include but is not limited to the logical judgment output of the real-time index and the threshold. The global model parameter can include but is not limited to the final model data aggregated when the training is terminated. For example, a neural network file containing the training weights of all constellation satellites, including but not limited to an encrypted parameter set processed by differential privacy.

[0109] In an exemplary embodiment, the satellite client performs the following training termination control operation:

[0110] S1, threshold initialization: parse the convergence standard (such as accuracy ≥ 90%) in the model training request;

[0111] S2, local metric calculation: evaluate the model using the validation data set after completing the local training.

[0112] S3, dynamic comparison decision: real-time comparison of current indicators with preset thresholds.

[0113] S4, global model transmission: after terminating the decision, the aggregate model transmission is started.

[0114] Example: A navigation satellite cluster relays the final positioning correction model to the ground station via inter-satellite links.

[0115] It should be noted that the termination mechanism offers room for optimization in multiple dimensions: dynamic adjustment can be supported in threshold setting; multi-indicator weighted scoring can be integrated in metric calculation; and a constellation voting mechanism can be introduced in decision-making. All variations of the above implementations fall within the scope of this solution and are not specifically limited in this application.

[0116] Through the embodiments of the present application, invalid training rounds are avoided, onboard computing resources are significantly saved, the on-orbit life of the satellite is extended, the training process is dynamically adjusted according to real-time performance, the robustness of the model in harsh space environments is improved, and key models are prioritized for feedback (such as disaster warning models) through a threshold classification mechanism. Single-satellite metric anomalies do not affect global decision-making, reliability is guaranteed through cross-validation of neighboring satellite data, and the practicality of low-orbit satellite federated learning is significantly improved. The training cycle of tasks such as ocean target monitoring is significantly shortened, while ensuring that key models in emergency situations (such as typhoon warnings) can be trained and federated in a relatively short time.

[0117] As an optional solution, determining the maximum communication loop based on link state information includes:

[0118] Build a network topology map based on a predetermined set of clients;

[0119] Determining the connection status between clients in the network topology graph based on the link status information;

[0120] Determine the maximum communication loop based on the network topology and connection status.

[0121] Optionally, in embodiments of the present application, the client set may include, but is not limited to, a group of satellite nodes participating in a federated learning task, whose members must meet data retention and computing resource requirements. For example, this may include a subset of satellites in a low-orbit constellation divided by orbital plane, including, but not limited to, static grouping based on satellite ID sequences or elastic clustering dynamically adjusted based on real-time load.

[0122] Optionally, in embodiments of the present application, the network topology graph may include, but is not limited to, a graph structure model representing inter-satellite communication relationships, with nodes representing satellite clients and edges representing inter-satellite links. For example, a polar orbit constellation topology comprising a plurality of nodes (corresponding to a plurality of satellites) and a plurality of directed edges may be constructed, including, but not limited to, a weighted graph (where edge weights represent link rates) or a dynamic graph (updated according to orbital cycles).

[0123] Optionally, in this embodiment of the present application, the aforementioned connection status may include, but is not limited to, the real-time on / off status of the intersatellite link and transmission performance indicators. For example, the satellite periodically reports the laser link connectivity matrix (1 indicates available, 0 indicates disconnected) and additional bit error rate and latency parameters, including but not limited to a link stability assessment value predicted by a Kalman filter.

[0124] Optionally, in an embodiment of the present application, the maximum communication loop may include, but is not limited to, a one-way closed path covering the most satellite nodes, which must satisfy a Hamiltonian circuit constraint. For example, a loop path including multiple satellites may be found in a topology graph through a depth-first search, including but not limited to a K-shortest path optimization scheme that considers link weights.

[0125] In an exemplary embodiment, the satellite client receives the maximum communication loop information sent by the server. The loop is generated by the server through the following process:

[0126] The server forms an initial set of available nodes from the constellation based on satellite registration information and resource status. For example, in a constellation of multiple satellites, nodes in the Earth's shadow or under maintenance are excluded to form a valid client set that includes all satellites.

[0127] A graph model is built based on a collection of clients. Nodes correspond to satellite spatial locations (e.g., orbital plane-sequence number codes), and edges are initialized according to inter-satellite link design rules. For example, the Walker Delta constellation automatically generates four edges for each node (the preceding and following nodes on the same orbit and the closest node on the adjacent orbit), forming a regular grid topology.

[0128] Map the real-time link data reported by satellites to the edge attributes of the topology graph. For example, if the Ku-Archaic band (Ka-band) link between satellites A and B is interrupted due to Doppler shift, the corresponding edge weight is set to infinity (indicating unavailable).

[0129] Searches for the loop with the highest node coverage in a constrained topology graph. It uses an improved depth-first search (DFS) algorithm to avoid link interruptions and optimizes overall transmission latency through path compression.

[0130] It should be noted that there are multiple implementation variations for topology construction and loop resolution: In the set construction dimension, data type filtering can be supported; in the topology modeling dimension, probabilistic graphical models can be used; and in the loop resolution dimension, ant colony algorithms can be introduced to optimize multi-objective paths. All variations of the above implementations fall within the scope of protection of this solution and are not specifically limited in this application.

[0131] By dynamically constructing the maximum communication loop, avoiding link interruptions and maximizing participating nodes, training continuity is ensured even under extreme conditions (such as the failure of multiple satellites in a single orbital plane). The optimal transmission path is generated based on real-time link quality, reducing the number of hops and end-to-end latency required for model synchronization. The topology-driven loop construction mechanism can adaptively adapt to the expansion of constellation scale (such as from hundreds to tens of thousands of satellites). The server only needs to periodically receive link status and calculate the loop, avoiding the continuous model transfer pressure of the traditional centralized architecture. This enables low-orbit satellite constellations to efficiently perform decentralized federated learning tasks under the constraints of highly dynamic changes in inter-satellite links, providing underlying support for on-board intelligent processing (such as real-time space weather forecasting and autonomous collision avoidance decisions).

[0132] As an optional solution, determining the maximum communication loop based on link state information includes:

[0133] Randomly select a client as the initial node from the network topology graph and build a path record structure;

[0134] Starting from the initial node, recursively explore each unvisited neighbor node based on the link state information. Each neighbor node explored is regarded as the current node.

[0135] Determine whether the current node meets the termination condition by marking the current node as visited and adding it to the end of the path record structure;

[0136] If the current node does not meet the termination condition, the node marked as unvisited among the adjacent nodes of the current node will be re-selected as the current node and explored again until the traversal is completed;

[0137] When the current node meets the termination condition, a maximum communication loop is generated.

[0138] Optionally, in an embodiment of the present application, the initial node may include, but is not limited to, the starting satellite client of the loop construction algorithm, and its selection does not affect the integrity of the final loop. For example, a satellite may be randomly selected as the search starting point in an orbital plane containing multiple satellites, including but not limited to polling by satellite ID hash value or prioritizing equatorial nodes based on geographic location.

[0139] Optionally, in an embodiment of the present application, the path record structure may include, but is not limited to, a dynamic data structure that stores a loop node sequence. For example, a doubly linked list may be used to sequentially record the access path from satellite node 1 → satellite node 2 → satellite node 3, including but not limited to a stack structure implementing a backtracking mechanism or an array structure supporting fast indexing.

[0140] Optionally, in an embodiment of the present application, the unvisited neighbor nodes may include, but are not limited to, neighboring nodes that have available intersatellite links with the current satellite and are not included in the path. For example, the neighbors of a satellite node include satellite nodes in the same orbit and satellite nodes in adjacent orbits.

[0141] Optionally, in an embodiment of the present application, the termination condition may include but is not limited to a criterion for determining when loop construction is complete, such as when the path includes all satellites or the search depth reaches a preset upper limit, including but not limited to detecting that the path is closed to form a loop or that the remaining nodes are unconnected.

[0142] In an exemplary embodiment, the process of the server performing recursive exploration to construct the maximum communication loop includes the following operations:

[0143] S1: Randomly select a satellite client from the network topology as the initial node (e.g., satellite node A deployed on orbital plane A) and create an empty path record structure. Initialize the global optimal loop storage variable and set the current path depth to 0.

[0144] S2, recursive exploration phase:

[0145] S2-1, node status marking: mark satellite node A as visited and add it to the end of the path record structure. The path is now [A];

[0146] S2-2, neighbor node screening: obtain A's unvisited neighbors and exclude nodes with broken link connections based on link status information;

[0147] S2-3, deep recursion: select satellite node B as the new current node, recursively perform the mark-join operation, and update the path to [A→B];

[0148] S2-4, termination judgment: When the path covers all available nodes or there are no available neighbors, compare the current path length with the historical optimal value and update the maximum loop record;

[0149] S3, backtracking mechanism:

[0150] S3-1, when all neighbors of satellite node B are inaccessible, satellite node B is removed from the path and marked as unvisited, and falls back to satellite node A;

[0151] S3-2, select the next unvisited neighbor satellite node C of satellite node A to continue exploring, forming a new path [A→C];

[0152] S3-3, execute the loop until all possible path branches are traversed.

[0153] S4, loop generation: When a direct link is detected between the first and last nodes of the path, the path is closed to form a communication loop, and the loop solution with the largest node coverage is output.

[0154] It should be noted that there are multiple implementations for recursive strategies and termination conditions: Priority strategies can be supported for neighbor selection (preferring nodes connected by high-bandwidth links); memoized search can be introduced to reduce repeated computations in the backtracking mechanism; and multi-objective optimization can be integrated in the termination decision (simultaneously optimizing loop length and total transmission delay). Any changes to the aforementioned algorithm implementations fall within the scope of this solution and are not specifically limited in this application.

[0155] Through the embodiments of this application, search paths are adjusted based on real-time link status, effectively addressing the challenges of intermittent intersatellite link interruptions. A backtracking mechanism avoids full-graph traversal, reduces computational complexity, adapts to the computing power constraints of onboard processors, and does not rely on fixed orbital topology. It supports loop generation for heterogeneous constellations (satellites with mixed inclination / altitude), ensures that the output loop covers the maximum set of connected nodes, and maximizes the number of participating satellites in each round of federated learning. This enables low-orbit satellite constellations to build efficient model synchronization paths despite the highly dynamic nature of intersatellite links, providing basic communication support for decentralized federated learning. Compared to traditional static routing, this significantly improves model aggregation efficiency while reducing the probability of training interruptions due to link interruptions.

[0156] As an optional solution, the current node is marked as visited and added to the end of the path record structure to determine whether the current node meets the termination condition, including:

[0157] When the total number of nodes in the path record structure is equal to the total number of nodes in the network topology graph and the first and last nodes coincide, a valid loop is generated;

[0158] When the length of the effective loop exceeds the historical maximum value, it is determined that the termination condition is met and the effective loop is updated to the maximum communication loop;

[0159] When all the adjacent nodes of the current node are marked as visited or no valid loop is found, the current node is removed from the end of the path record structure and the access status of the current node is reset.

[0160] Optionally, in an embodiment of the present application, the path record structure may include, but is not limited to, a dynamic storage container for storing the node access sequence during loop construction. For example, a stack structure may be used to record the satellite node access sequence, including, but not limited to, a bidirectional linked list for fast head-to-tail operations, or a tree structure for supporting branch backtracking.

[0161] Optionally, in an embodiment of the present application, the above-mentioned valid loop may include but is not limited to a closed communication path that satisfies end-to-end connectivity and covers multiple nodes.

[0162] Optionally, in an embodiment of the present application, the above-mentioned historical maximum value may include, but is not limited to, the optimal number of loop nodes recorded during the execution of the algorithm. For example, the maximum value record dynamically updated during the recursive search includes, but is not limited to, the optimal value of a sliding window with time decay.

[0163] Optionally, in embodiments of the present application, the access status reset may include, but is not limited to, a flag clearing operation when a node exits a path. For example, after a satellite node is removed from a path, its status is restored from "visited" to "unvisited," including, but not limited to, a state machine-driven flag management mechanism.

[0164] In an exemplary embodiment, the server determines the recursive exploration termination condition through the following logic:

[0165] S1, valid loop generation condition verification: When the number of nodes in the path record structure is equal to the total number of available satellites in the constellation and a physical link exists between the head and tail nodes, the loop validity check is triggered; the spatial positions of the head and tail nodes are verified to be connected, and a valid loop instance is generated;

[0166] S2, loop optimization judgment: compare the current number of valid loop nodes with the historical maximum value record; when the new loop covers more nodes, update the historical maximum value and store the loop; mark the current search branch as meeting the termination condition and stop exploring the path.

[0167] S3, backtracking trigger mechanism: If all adjacent satellites of the current node have been visited; or the remaining unvisited nodes cannot be connected to the current node (for example, due to an intersatellite link interruption); perform a backtracking operation: remove the satellite node from the end of the path, reset its access status to unvisited; and return to the previous node to continue exploring other branches.

[0168] It should be noted that the termination decision mechanism has multiple implementation variations: Link quality constraints can be added to the loop verification dimension (e.g., head and tail link bandwidth > 1Gbps); multi-objective optimization can be introduced to the optimal value update dimension (simultaneously comparing the number of nodes and path latency); and partial path retention can be supported in the backtracking strategy dimension (e.g., retaining a stable sub-path of 10 consecutive nodes). All variations of the above implementations fall within the scope of this solution and are not specifically limited in this application.

[0169] Through the embodiments of this application, the actual transmission of the loop is ensured by verifying the end-to-end connectivity, avoiding invalid paths that are mathematically feasible but physically unreachable, dynamically updating the historical optimal solution, so that the loop construction process continues to approach the global optimum rather than the local optimum. The intelligent backtracking mechanism reduces invalid searches, efficiently completes path planning under the limited computing power of the onboard processor, responds to changes in link status in real time, and can quickly generate alternative solutions when a node in the optimal loop fails. This significantly improves the model synchronization efficiency of low-orbit satellite constellations in federated learning, significantly reduces the time spent on inter-satellite parameter exchange, and significantly controls the loop calculation time of large-scale constellations, providing basic support for real-time intelligent processing on board.

[0170] As an optional solution, the current node is marked as visited and added to the end of the path record structure to determine whether the current node meets the termination condition, including:

[0171] When the total number of nodes in the path record structure is equal to the total number of nodes in the network topology graph and the first and last nodes coincide, a valid loop is generated;

[0172] When the length of the valid loop exceeds a historical maximum value, determining the sum of the weights of the edges in the valid loop, wherein the weight of each edge is used to indicate a communication rate of each edge;

[0173] When the sum of the weights of the edges in the valid loop exceeds the historical maximum value, it is determined that the termination condition is met and the valid loop is updated to the maximum communication loop;

[0174] When all the adjacent nodes of the current node are marked as visited or no valid loop is found, the current node is removed from the end of the path record structure and the access status of the current node is reset.

[0175] Optionally, in this embodiment of the present application, the edge weights may include, but are not limited to, numerical indicators that quantify intersatellite link transmission performance, calculated based on real-time communication status data. For example, the weight value may be the product of the available bandwidth (in Gbps) of the Ku-Archaic band (Ka-band) link and the stability coefficient (in the range of 0-1), including but not limited to the inverse of transmission delay or the effective rate after bit error rate compensation.

[0176] Optionally, in an embodiment of the present application, the sum of the above weights may include but is not limited to a comprehensive evaluation value of all inter-satellite link performance indicators on the loop path, including but not limited to a linear combination of bandwidth products or delay inverses after logarithmic transformation.

[0177] Optionally, in the embodiment of the present application, the above-mentioned historical maximum values ​​may include but are not limited to weights and optimal values ​​recorded during the execution of the algorithm. For example, the current highest weight and record may be dynamically stored, including but not limited to the optimal value of the sub-region stored by track plane.

[0178] In an exemplary embodiment, the server adds a weight optimization dimension based on the number of nodes reaching the standard, including but not limited to the following steps:

[0179] S1, valid loop generation: When the number of path nodes is equal to the number of available satellites in the constellation and the end is connected, loop validity verification is triggered;

[0180] S2, dual-objective judgment: compare the current number of loop nodes with the historical maximum (e.g., new loop 96 nodes > historical 94 nodes); if the number of nodes is the same or better, calculate the total loop weight (e.g., ∑ bandwidth × stability);

[0181] S3, termination condition upgrade: only when the following conditions are met at the same time: the number of nodes ≥ the historical optimal and the sum of weights > the historical optimal weight; update the historical records and store the loop solution;

[0182] S4, intelligent backtracking mechanism: When all neighbors of a node have been visited but no better loop has been formed, the terminal node is removed and the state is reset, and new branches are explored after backtracking;

[0183] It should be noted that there are multiple implementations for weight calculation and decision strategies. Weight definition can incorporate factors such as link bit error rate (e.g., 1 / BER) and transmission energy efficiency (bit / Joule). The decision logic can support Pareto optimal solution screening (a solution set that balances the number of nodes and the sum of the weights). Backtracking optimization can incorporate simulated annealing algorithms to avoid local optimality. Any variations of these implementations fall within the scope of this solution and are not specifically limited in this application.

[0184] Through the embodiments of the present application, this multi-objective optimization mechanism brings about a breakthrough improvement, ensuring maximum node coverage while optimizing high-speed link combinations, significantly reducing model synchronization time. It dynamically adjusts weight coefficients based on the real-time characteristics of the links to adapt to changes in the inter-satellite communication environment, such as rain attenuation and space interference. It prioritizes low-power laser links, significantly reducing onboard energy consumption. When a single point in the optimal loop fails, a suboptimal solution (fewer nodes but higher weights) can seamlessly take over. This achieves the coordinated optimization of communication efficiency and model accuracy in federated learning for low-orbit satellites, providing a highly reliable communication foundation for tasks such as onboard real-time target recognition and space weather forecasting. Compared to single-objective optimization solutions, training task completion time is significantly shortened, while the probability of model synchronization failure due to link instability is reduced.

[0185] The following is a further explanation of this application with reference to specific examples:

[0186] Satellite Internet, as a key communication infrastructure connecting the world, is developing rapidly. Its core component, Low Earth Orbit (LEO) satellite constellation, expands the coverage of satellite Internet effectively and accumulates rich data resources by networking multiple LEO satellites. As data holders, LEO satellites hold various types of data such as user location, communication traffic, and satellite operating status, which are crucial for promoting the intelligent transformation of satellite Internet. However, how to achieve intelligent data processing while protecting data privacy and security has become a difficult problem to be solved. Therefore, Federated Learning (FL) is introduced, which allows multiple data holders (i.e., LEO satellites) to perform deep processing and analysis of data without sharing raw data, thereby building efficient Artificial Intelligence (AI) models and promoting the development of satellite Internet towards a more intelligent direction.

[0187] In the field of satellite Internet, the traditional federated learning method based on LEO satellite constellation adopts a "centralized" learning framework, as shown in FIG. 1. The federated learning framework includes a federated learning (FL) server and a client. Figure 4

[0188] The FL server includes the following functional modules:

[0189] (1) Client device management: manage the registration, participation, and exit of client devices; select client devices to participate in learning according to device status (such as computing power, network condition, etc.);

[0190] (2) Task management: support federated learning training task initiation request, provide initial FL parameters; support federated learning model monitoring, model monitoring information includes model performance, state, etc.; support federated learning model performance evaluation, decide whether to continue or stop the training process according to the evaluation results;

[0191] (3) Model aggregation: collect local models from clients to aggregate and generate a global model.

[0192] The client has data collection and model training functions.

[0193] In this framework, each satellite acts as a client, trains a model using its own local data, and then uploads the trained local model to the ground center server (i.e., FL server). After receiving all local models, the FL server aggregates the parameters to generate a global model, which is then distributed to all satellite clients for the next round of training. Repeat the above process until the training termination condition is met.

[0194] ​To more clearly show the specific implementation of federated learning in low-orbit satellite networks, the federated learning mechanism between Network Data Analytics Functions (NWDAFs) in the 3rd Generation Partnership Project (3GPP) standard is taken as an example for illustration. Federated learning performs FL model training through a server and multiple clients. Figure 5 The connection structure between multiple NWDAFs for implementing federated learning is given.

[0195] As shown in Figure 5 , the server connects multiple clients. In a federated learning system for low-orbit satellite networks, the FL server is usually a ground station (such as a gateway station, a ground base station, etc.), which can provide functions such as client selection and model aggregation; the client is a satellite with local data and performs model training, which can collect data from Network Functions (NFs) or an Operation, Administration, and Maintenance System (OAM) and train a local model through a Model Training Logic Function (MTLF). Among them, the NFs include Access and Mobility Management Function (AMF), Session Management Function (SMF), and Unified Data Management (UDM), etc.

[0196] Based on the 3GPP standard, Figure 6 the training process of federated learning between multiple NWDAFs is given.

[0197] S1, FL client selection: the FL server selects FL clients containing a Multi-Task Learning Framework (MTLF) to participate in federated learning training.

[0198] S2, model training request sending: the FL server sends a model training request to the selected clients and provides federated learning parameters required for the clients to perform model training. The federated learning parameters include an initial global model, model metric indicators (such as model accuracy), etc.

[0199] S3, local model training: each client trains the model provided by the server based on local data to generate a local model.

[0200] S4, training result sending: after the client completes the local training, the training result is sent to the server, and the training result includes the local model parameter, model metric value, etc.

[0201] S5, model aggregation: after the FL server receives the training results of all clients, the local model parameters are aggregated to generate a global model.

[0202] S6, model evaluation: according to the model metric value provided by the FL client, the model performance is comprehensively evaluated to determine whether to terminate the training. If the training is terminated, step S7 is not executed, and the FL training is ended.

[0203] S7, global model parameter distribution: if the federated learning training process continues, the server sends the aggregated global model to the selected client for the next round of FL training.

[0204] Steps S3-S7 are repeatedly executed until the training termination condition (such as model accuracy reaching a threshold) is reached.

[0205] The present application proposes a decentralized federated learning scheme for low-orbit satellite constellation, which monitors the inter-satellite link state in real time and designs an adaptive decentralized model interaction and aggregation method. In the decentralized federated learning framework, the clients can directly communicate to synchronize and aggregate the model, without the need for "centralized" model aggregation through the central server, thereby relieving the communication pressure of a single node, reducing the delay and bandwidth occupation of model transmission, and avoiding the risk of single point failure.

[0206] The present application provides a decentralized federated learning method for low-orbit satellite constellation. Unlike the traditional federated learning framework which relies on the FL server for centralized model aggregation, the present scheme proposes a decentralized model interaction communication and aggregation mechanism, and the satellite clients directly communicate and cooperate to synchronize and aggregate the model, thus effectively relieving the communication bottleneck and avoiding the risk of single point failure.

[0207] Figure 7 The proposed decentralized federated learning framework for low-orbit satellite constellation is demonstrated. In this framework, the server can be a ground station (such as a gateway station, a ground base station, etc.) or a specific satellite, and the client is a satellite that holds local data and trains the model. The server and the client need to have the ability of data collection and analysis processing (such as NWDAF network element).

[0208] Compared with the traditional federated learning framework, the following functions are added to the server in the present framework:

[0209] Client model interactive communication management: supports the collection of inter-satellite link status information, formulates the client model interactive communication plan based on the inter-satellite link status information, and distributes it to the client;

[0210] The following new features are added to the client:

[0211] (1) Model interaction: supports reporting of inter-satellite link status information; supports receiving model interaction communication schemes from the server, and sends its own local model to other clients and receives models from other clients according to the scheme;

[0212] (2) Model aggregation: responsible for aggregating all collected client models to generate a global model.

[0213] Next, the operation process of the decentralized federated learning method for low-orbit satellite constellations proposed in this technical solution is introduced in detail. Figure 8 shown.

[0214] S1, FL client selection: The FL server selects FL clients with data collection and processing capabilities to participate in federated learning training.

[0215] S2, Model Training Request Sending: The FL server sends a model training request to the selected client and provides the federated learning parameters required for the client to perform model training. Federated learning parameters include initializing the global model and model metrics (such as model accuracy).

[0216] S3, local model training: Each client trains a model based on a local dataset to generate a local model.

[0217] S4, sending training results and inter-satellite link status information: When the client completes local training, it sends the training results (including model metrics, etc., excluding local model parameters) and inter-satellite link status information to the server.

[0218] S5, Model evaluation: Figure 9 As shown in the figure, after receiving the model metrics provided by the client, the server comprehensively evaluates the model performance to determine whether to terminate training. If the model performance requirements are met, the server sends a stop training request and a global model upload request to the client (this request can be sent to the client along with the communication interaction plan in step S7). Then, steps S6, S7, S8, and S9 are executed, concluding training. If the model performance requirements are not met, steps S6, S7, and S8 are executed, step S9 is skipped, and the next round of training begins.

[0219] S6, model interaction communication scheme design: The server designs a model interaction communication scheme based on the inter-satellite link status information. The scheme defines the communication topology and the communication path between the clients, and guides the clients to exchange models according to the scheme.

[0220] S7, Model Interaction Communication Plan Distribution: The server sends the model interaction communication plan to all clients. If the model evaluation result in step S5 is to stop training, a stop training request and a global model upload request must be sent to the client together.

[0221] S8, decentralized model interaction and aggregation: Each client performs model interaction according to the received model interaction communication scheme. After the exchange is completed, each client has the model parameters of all other clients (this process is called model synchronization). Then each client aggregates all model parameters to generate a global model.

[0222] S9, global model sending: If FL training is stopped, the client sends the final global model to the server.

[0223] If FL training continues, steps 3-8 are repeated until the training termination condition is reached.

[0224] In summary, the innovation of this invention lies in its proposal for a decentralized model interaction and aggregation solution for low-orbit satellite constellations. Instead of sending local model parameters to a server for centralized model aggregation, clients communicate directly with each other to synchronize and aggregate models. Because the data transmitted between the server and clients is very small, the server does not experience any communication pressure.

[0225] Unlike terrestrial networks, low-orbit satellite constellation networks have the following two topological characteristics:

[0226] Deterministic neighbor relationship: such as Figure 10 As shown, each satellite maintains intersatellite links with its four adjacent satellites, that is, two are in the same orbit and two are in adjacent orbits. 11 , its four adjacent satellites are satellite S 12 、S 13 (two adjacent satellites in the same orbit) and satellite S 21 、S 31 (Two satellites in adjacent orbits). These satellites can communicate within and between planes via intersatellite links. The solid lines in the figure represent intersatellite links within the orbital plane, and the dotted lines represent intersatellite links between planes.

[0227] Intermittent interruption of intersatellite links: Although there is a deterministic neighbor relationship, due to the high-speed relative motion between adjacent satellites, the intersatellite link is not continuously stable and may be interrupted intermittently, thus affecting the model interaction between clients. Figure 10 As shown, satellite S 11 With S 12 and satellite S 12With S 32 The communication link between them is interrupted.

[0228] To address the problem of intermittent interruption of intersatellite links, this application proposes an innovative model interaction communication and aggregation solution to ensure that as many client models as possible can interact and aggregate, thereby accelerating the FL training process. Figure 11 As shown, the workflow of the scheme is as follows:

[0229] S1, low-orbit satellite network topology map construction: After the server receives the inter-satellite link status information (including whether the communication link is connected, the communication link rate, etc.) sent by all satellite clients, it first constructs the communication network topology map G = (V, E), where is a set of nodes, representing satellite clients; is an edge set, representing intersatellite links. Figure 12 As shown in the figure, if there is an edge between two satellite nodes (a solid black line with double arrows), data can be transmitted between them. If there is no edge between the two satellites, the communication link between them is interrupted. In addition, each edge can also be assigned a corresponding weight (such as the communication link rate).

[0230] S2, Maximum Communication Loop Construction: Based on the constructed network topology, the goal is to find a path that passes through as many satellite nodes as possible exactly once and ultimately returns to the starting point (this path is known as the maximum communication loop). Alternatively, based on the communication link weights (rates), the sum of the weights (rates) of all edges on the path can be maximized while ensuring the maximum loop. The solution to this problem can be a graph traversal algorithm (such as depth-first search) or a heuristic algorithm (such as a genetic algorithm).

[0231] Next, we introduce a depth-first search (DFS) algorithm to solve the maximum communication loop problem. The algorithm includes the following key steps:

[0232] S2-1, starting point selection: Randomly select a node as the starting point. The choice of the starting point has no decisive influence on the final result, because the algorithm will search multiple times from each node to find the global optimal solution.

[0233] S2-2, path record: define a data structure (stack or list) to record the nodes on the current path.

[0234] S2-3, Depth-first search: Starting from the starting point, recursively explore each unvisited neighbor node. For each neighbor node, the algorithm performs the following operations:

[0235] S2-3-1, mark the current node as visited;

[0236] S2-3-2, add the current node to the path record;

[0237] S2-3-3, check whether the termination condition is met. If the number of nodes in the path record is equal to the total number of nodes in the graph, and the last node is the same as the starting point, it means that a loop passing through all nodes has been found, the algorithm stops running, and the communication loop is output; if the path length exceeds the previously recorded maximum loop length, and the last node is the same as the starting point, the maximum loop record is updated;

[0238] S2-3-4, recursively explore each unvisited neighbor of the current node;

[0239] S2-3-5, backtracking: If all neighbors have been visited or no path that meets the conditions is found, the current node is removed from the path record and marked as unvisited.

[0240] S2-4, Result Update: During each search, the algorithm updates the record of the largest loop found. Finally, the algorithm outputs the largest communication loop found in all searches.

[0241] For example, Figure 12 The network topology shown is input into the maximum loop construction algorithm mentioned above, and the algorithm outputs a communication loop for model interaction: 11 →s 13 →s 12 →s 22 →s 23 →s 33 →s 32 →s 31 →s 21 →s 11 ,The nodes in the loop are the satellite clients that participate in model interaction and aggregation.

[0242] S3, Model Interaction: Assume that the co- clients, {s1, s2⋯s M},this The clients form a ring-shaped communication link. The Ring AllReduce algorithm is used to implement interactive synchronization of the model, so that each client has the model parameters of all other clients. It includes the following three steps:

[0243] S3-1, model parameter segmentation: In the Ring AllReduce algorithm, each satellite first needs to divide its local model parameters into M blocks.

[0244] S3-2, execute the scatter-reduce version of the Ring AllReduce algorithm: Each satellite sums the block received from the previous satellite with its own block and sends the updated block to the next satellite. This process is repeated M-1 times, and each satellite obtains partial model parameters from all other satellites.

[0245] S3-3, All-Gather using the Ring AllReduce algorithm: Similar to Scatter-Reduce, in the All-Gather phase, satellites also send and receive blocks M-1 times. However, instead of accumulating received blocks, the received block data is directly used to replace the original block data. After this phase, each satellite has obtained all the model parameters of all other satellites.

[0246] S3-4, model aggregation: After the interactive synchronization of the models is completed, each satellite contains all the model parameter data of all other satellites, and these model parameters are aggregated to generate a global model.

[0247] In one exemplary embodiment, NWDAF functionality is introduced into a low-orbit satellite network to support the training of a network traffic prediction model based on federated learning (FL). Specifically, a FL server and multiple clients collaborate to train a network traffic prediction model. In this scenario, the FL server is deployed on the ground, and the clients are deployed on low-orbit satellites.

[0248] like Figure 13 As shown in Figure 2, four low-orbit satellites with NWDAF deployed are considered as FL clients. Each client collects network traffic data from NFs such as session management function (SMF). The collected local traffic data is expressed as . represents the traffic data of the nth satellite client in the mth time interval. The traffic forecasting problem is modeled as a time series forecasting problem, that is, predicting future network traffic based on historical traffic data. Assume is the traffic that needs to be predicted, then the traffic prediction problem can be described as:

[0249] ;

[0250] Among them, f is the network traffic prediction model, and W is the parameter corresponding to the prediction model. The network traffic prediction model structure is as follows Figure 14 As shown in Figure 1, it consists of a four-layer feedforward neural network, including one input layer, two hidden layers, and one output layer. The input layer is responsible for receiving and initially processing raw traffic data, the hidden layer performs deep data processing and feature extraction, and the output layer generates the final prediction value based on the processing results of the hidden layer.

[0251] Based on the above network traffic prediction model, the decentralized federated learning method for low-orbit satellite constellations proposed in this application is applied to achieve distributed training of the model. The operation process of this method is as follows:

[0252] like Figure 15 As shown in the figure, the operation process of implementing decentralized federated learning between multiple NWDAFs includes but is not limited to the following steps:

[0253] S1, FL client selection: The FL server selects clients that contain model training logic functions (MTLF) to participate in federated learning training.

[0254] S2, model training request sending: The FL server sends a model training request to the selected client. The request information includes the randomly initialized traffic prediction model parameters W0 and the required model metrics (such as model accuracy).

[0255] S3, local model training: The client collects network traffic data from NFs such as SMF and trains the traffic prediction model based on the collected local data. After the training is completed, the local model parameters are obtained. Where k represents the index of the satellite client and t represents the round of FL training.

[0256] S4, sending training results and inter-satellite link status information: After the client completes local model training, it sends the training results (excluding local model parameters) such as model metrics (such as model accuracy) and inter-satellite link status information to the server.

[0257] S5, Model Evaluation: After receiving the model metrics provided by the client, the server comprehensively evaluates the model performance to determine whether to terminate training. If the traffic prediction model's accuracy exceeds a predefined threshold, the server sends a stop training request and a global model upload request to the client (these requests can be sent to the client along with the communication interaction plan in step S7). Training concludes after executing steps S6, S7, S8, and S9. If the model performance requirements are not met, steps S6, S7, and S8 are executed, step S9 is skipped, and the next round of training begins.

[0258] S6, Model Interaction Communication Scheme Design: The server designs a model interaction communication scheme based on the inter-satellite link status information. The scheme defines the network topology and the communication path between the client and guides the client to exchange models according to the scheme. Assume that the model interaction communication scheme given by the server is .

[0259] S7, Model Interaction Communication Plan Distribution: The server sends the model interaction communication plan to the selected client. If the model evaluation result in step S5 is to stop training, a stop training request and a global model upload request must be sent to the client together.

[0260] S8, Decentralized Model Interaction and Aggregation:

[0261] S8-1, Model Interaction: The Ring AllReduce algorithm is used to achieve interactive synchronization of the model, so that each client has the model parameters of all other clients. It includes the following three steps:

[0262] S8-1-1, model parameter segmentation: Figure 16 As shown, each satellite divides its model parameters into data blocks. For example, Model parameters It is divided into 4 blocks: a0, a1, a2 and a3.

[0263] S8-1-2, execute the Scatter-Reduce of Ring AllReduce algorithm: Figure 17 As shown, the four satellites need to perform three Scatter-Reduce steps. When the Scatter-Reduce step is performed for the first time, Figure 17 As shown by the middle arrow, satellite s1 sends its first block a0 to the next satellite s2, satellite s1 sends its second block b1 to the next satellite s3, satellite s3 sends its third block c2 to the next satellite s4, and satellite s4 sends its fourth block d3 to the next satellite s1. After receiving the block data sent by the previous satellite, each satellite adds it to the block data at its corresponding position. After the first Scatter-Reduce is executed, the first block data of satellite s2 is updated to a0+b0, the second block data of satellite s3 is updated to b1+c1, the third block data of satellite s4 is updated to c2+d2, and the fourth block data of satellite s1 is updated to a3+d3. The updated block data is in Figure 17 Next, the second and third Scatter-Reduce operations are performed, and the final block data on each satellite is shown in the dotted box.

[0264] S8-1-3, execute the All-Gather of Ring AllReduce algorithm: Figure 18As shown in FIG, after executing All-Gather, the block data on each satellite is shown in the dotted box, and the block of each satellite contains all the model parameter data of all other satellites.

[0265] S8-2, Model Aggregation: After the interactive synchronization of the models is completed, each satellite contains all the model parameter data of all other satellites. Figure 18 As shown, these model parameters are aggregated to generate a global model:

[0266] ;

[0267] S9, global model sending: If FL training is stopped, the client sends the final global model to the server. This model is the trained network traffic prediction model.

[0268] If FL training continues, steps S3-S8 are repeated until the training termination condition is reached.

[0269] It is understandable that in the specific implementation of this application, related data such as user information is involved. When the above embodiments of this application are applied to specific products or technologies, user permission or consent is required, and the collection, use and processing of relevant data must comply with relevant laws, regulations and standards of relevant countries and regions.

[0270] It should be noted that for the aforementioned method embodiments, for the sake of simplicity, they are all expressed as a series of action combinations, but those skilled in the art should be aware that this application is not limited by the order of the actions described, because according to this application, certain steps can be performed in other orders or simultaneously. Secondly, those skilled in the art should also be aware that the embodiments described in the specification are all preferred embodiments, and the actions and modules involved are not necessarily required by this application.

[0271] According to another aspect of the embodiment of the present application, a model data processing device for implementing the above-mentioned model data processing method is also provided. Figure 19 As shown, the device includes:

[0272] A training module 1902 is configured to respond to a model training request sent by the server, perform training based on local training data and initial model parameters, obtain local model parameters and link state information, and send the link state information to the server, wherein the model training request includes the initial model parameters;

[0273] A first receiving module 1904 is configured to receive a maximum communication loop determined by the server based on the link state information, where the maximum communication loop represents a communication path that passes through each of M clients a number of times that satisfies a preset number condition and where M has a maximum value, where M is a positive integer;

[0274] A generating module 1906 is configured to sequentially obtain local model parameters corresponding to other clients except the client itself according to the maximum communication loop, and generate global model parameters;

[0275] Aggregation module 1908 is used to aggregate local model parameters and global model parameters to obtain global model parameters.

[0276] As an optional solution, the above-mentioned device is used to obtain the local model parameters corresponding to other clients except itself in sequence according to the maximum communication loop in the following manner to generate global model parameters: divide the local model parameters into M blocks based on the number of clients in the maximum communication loop; and perform distributed accumulation and synchronization on the M blocks in sequence according to the maximum communication loop to generate global model parameters.

[0277] As an optional solution, the above-mentioned device is used to perform distributed accumulation and synchronization on M blocks in sequence according to the maximum communication loop in the following manner to generate global model parameters: based on the maximum communication loop, the blocks received from the previous client are summed with the own blocks in sequence, and the updated blocks are sent to the next client, and the execution is repeated M-1 times to obtain intermediate model parameters; based on the maximum communication loop, the intermediate model parameters received from the previous client are used to replace the intermediate model parameters stored in the self, and the execution is repeated M-1 times to generate global model parameters.

[0278] As an optional solution, the above-mentioned device is also used to: determine the model measurement parameter threshold based on the model training request; determine the current model measurement parameter after training based on local training data and initial model parameters; determine whether to end training based on the comparison result of the model measurement parameter threshold and the current model measurement parameter; and send the global model parameters to the server when it is determined that training needs to be ended.

[0279] According to another aspect of the embodiment of the present application, a model data processing device for implementing the above-mentioned model data processing method is also provided. Figure 20 As shown, the device includes:

[0280] A sending module 2002 is configured to send a model training request to a client, wherein the model training request includes initial model parameters;

[0281] A second receiving module 2004 is configured to receive link state information sent by the client, wherein the link state information represents information obtained by the client through training based on the local training data and the initial model parameters;

[0282] a determination module 2006 configured to determine a maximum communication loop based on the link state information, wherein the maximum communication loop represents a communication path that passes through each of the M clients a number of times that satisfies a preset number condition and where M has a maximum value, where M is a positive integer;

[0283] The third receiving module 2008 is used to receive the global model parameters uploaded by the client, wherein the global model parameters represent model parameters generated by the client aggregating the local model parameters corresponding to other clients except itself obtained in sequence according to the maximum communication loop.

[0284] As an optional solution, the device is used to determine the maximum communication loop based on the link status information in the following manner: constructing a network topology diagram based on a predetermined client set; determining the connection status between clients in the network topology diagram based on the link status information; and determining the maximum communication loop based on the network topology diagram and the connection status.

[0285] As an optional solution, the device is used to determine the maximum communication loop based on the link status information in the following manner: randomly select a client as an initial node from the network topology diagram and construct a path record structure; starting from the initial node, recursively explore each unvisited neighbor node based on the link status information, and the neighbor node explored each time is regarded as the current node; by marking the current node as a visited state and adding it to the end of the path record structure, determine whether the current node meets the termination condition; if the current node does not meet the termination condition, reselect the node marked as an unvisited state among the adjacent nodes of the current node as the current node and re-explore until the traversal is completed; if the current node meets the termination condition, generate the maximum communication loop.

[0286] As an optional solution, the device is used to determine whether the current node meets the termination condition by marking the current node as a visited state and adding it to the end of the path record structure in the following manner: when the total number of nodes in the path record structure is equal to the total number of nodes in the network topology graph and the head and tail nodes coincide, a valid loop is generated; when the length of the valid loop exceeds the historical maximum value, it is determined that the termination condition is met, and the valid loop is updated to the maximum communication loop; wherein, when the adjacent nodes of the current node are all marked as the visited state or the valid loop is not found, the current node is removed from the end of the path record structure and the access state of the current node is reset.

[0287] As an optional solution, the device is used to determine whether the current node meets the termination condition by marking the current node as a visited state and adding it to the end of the path record structure in the following manner: when the total number of nodes in the path record structure is equal to the total number of nodes in the network topology graph and the head and tail nodes coincide, a valid loop is generated; when the length of the valid loop exceeds the historical maximum value, the sum of the weights of the edges in the valid loop is determined, wherein the weights of the edges are used to indicate the communication rate of the edges; when the sum of the weights of the edges in the valid loop exceeds the historical maximum value, it is determined that the termination condition is met, and the valid loop is updated to the maximum communication loop; wherein, when the adjacent nodes of the current node are all marked as the visited state or the valid loop is not found, the current node is removed from the end of the path record structure and the access state of the current node is reset.

[0288] In the embodiments of the present application, the term "module" or "unit" refers to a computer program or portion of a computer program that has a predetermined function and works together with other related parts to achieve a predetermined goal. It can be implemented in whole or in part using software, hardware (such as processing circuits or memory), or a combination thereof. Similarly, a processor (or multiple processors or memories) can be used to implement one or more modules or units. In addition, each module or unit can be part of an overall module or unit that includes the functionality of the module or unit.

[0289] Regarding the apparatus in the above embodiment, the specific manner in which each module performs operations has been described in detail in the embodiment of the method, and will not be elaborated here.

[0290] According to one aspect of the present application, a computer program product is provided, comprising a central processing unit (CPU) capable of executing various appropriate actions and processes based on a program stored in a read-only memory (ROM) or a program loaded from a storage unit into a random access memory (RAM). The RAM also stores various programs and data required for system operation. The CPU, the ROM, and the RAM are interconnected via a bus. Input / output interfaces (I / O interfaces) are also connected to the bus.

[0291] The following components are connected to the input / output interface: an input section including a keyboard and mouse; an output section including cathode ray tubes (CRTs), liquid crystal displays (LCDs), and speakers; a storage section including a hard disk; and a communication section including network interface cards such as local area network cards and modems. The communication section performs communication processing via a network such as the Internet. Drives are also connected to the input / output interface as needed. Removable media such as magnetic disks, optical disks, magneto-optical disks, and semiconductor memories are installed in the drive as needed, allowing computer programs read from these media to be installed in the storage section as needed.

[0292] In particular, according to an embodiment of the present application, the processes described in the various method flow charts can be implemented as computer software programs. For example, an embodiment of the present application includes a computer program product comprising a computer program carried on a computer-readable medium, the computer program containing program code for executing the methods shown in the flow charts. In such an embodiment, the computer program can be downloaded and installed from a network via a communication portion, and / or installed from a removable medium. When the computer program is executed by a central processing unit, the various functions defined in the system of the present application are performed.

[0293] In such an embodiment, the computer program can be downloaded and installed from a network via the communication portion, and / or installed from a removable medium. When the computer program is executed by the central processing unit, various functions provided by the embodiments of the present application are performed.

[0294] According to another aspect of the embodiment of the present application, an electronic device for implementing the above-mentioned model data processing method is also provided. The electronic device may be Figure 1 The terminal device or server shown. This embodiment is described by taking the electronic device as an example of a terminal device. The electronic device includes a memory and a processor, the memory stores a computer program, and the processor is configured to execute the steps of any of the above method embodiments through the computer program.

[0295] Optionally, in this embodiment, the electronic device may be located in at least one network device among a plurality of network devices of a computer network.

[0296] Optionally, in this embodiment, the above-mentioned processor can be configured to execute the methods in each embodiment of the present application through a computer program.

[0297] Among them, the memory can be used to store software programs and modules, such as the program instructions / modules corresponding to the method and device for processing model data in the embodiments of the present application. The processor executes various functional applications and data processing by running the software programs and modules stored in the memory, that is, realizing the above-mentioned method for processing model data. The memory may include a high-speed random access memory, and may also include a non-volatile memory, such as one or more magnetic storage devices, flash memory, or other non-volatile solid-state memory. In some instances, the memory may further include a memory remotely arranged relative to the processor, and these remote memories can be connected to the terminal via a network. Examples of the above-mentioned network include but are not limited to the Internet, an intranet, a local area network, a mobile communication network and a combination thereof.

[0298] Optionally, the transmission device of the electronic device is used to receive or send data via a network. Specific examples of the aforementioned network may include wired networks and wireless networks. In one embodiment, the transmission device includes a network interface controller (NIC), which can be connected to other network devices and a router via a network cable to communicate with the Internet or a local area network. In one embodiment, the transmission device is a radio frequency (RF) module, which is used to communicate with the Internet wirelessly.

[0299] In other embodiments, the terminal device or server may be a node in a distributed system, wherein the distributed system may be a blockchain system, and the blockchain system may be a distributed system formed by connecting multiple nodes via network communication. The nodes may form a peer-to-peer network, and any computing device, such as a server, terminal, or other electronic device, may become a node in the blockchain system by joining the peer-to-peer network.

[0300] According to one aspect of the present application, a computer-readable storage medium is provided, and a processor of an electronic device reads the computer instructions from the computer-readable storage medium, and the processor executes the computer instructions, so that the electronic device executes the model data processing method provided in various optional implementations of the above-mentioned model data processing.

[0301] Optionally, in this embodiment, the above-mentioned computer-readable storage medium can be configured to store data for executing the methods in various embodiments of the present application.

[0302] Optionally, in this embodiment, a person of ordinary skill in the art may understand that all or part of the steps in the various methods of the above embodiments may be completed by instructing hardware related to the terminal device through a program, and the program may be stored in a computer-readable storage medium, which may include: a flash drive, a read-only memory (ROM), a random access memory (RAM), a magnetic disk or an optical disk, etc.

[0303] The serial numbers of the above embodiments of the present application are for description only and do not represent the advantages or disadvantages of the embodiments.

[0304] If the integrated units in the above embodiments are implemented in the form of software functional units and sold or used as independent products, they can be stored in the above-mentioned computer-readable storage medium. Based on this understanding, the technical solution of the present application, or the part that contributes to the prior art, or all or part of the technical solution can be embodied in the form of a software product. The computer software product is stored in a storage medium and includes a number of instructions for causing one or more electronic devices to execute all or part of the steps of the method described in each embodiment of the present application.

[0305] In the above embodiments of the present application, the description of each embodiment has its own focus. For parts that are not described in detail in a certain embodiment, please refer to the relevant description of other embodiments.

[0306] In the several embodiments provided in this application, it should be understood that the disclosed applications can be implemented in other ways. Among them, the device embodiments described above are only schematic. For example, the division of the units is only a logical function division. In actual implementation, there may be other division methods, such as multiple units or components can be combined or integrated into another system, or some features can be ignored or not executed. Another point is that the mutual coupling or direct coupling or communication connection shown or discussed can be through some interfaces, indirect coupling or communication connection of units or modules, which can be electrical or other forms.

[0307] The units described as separate components may or may not be physically separate, and the components shown as units may or may not be physical units, that is, they may be located in one place or distributed across multiple network units. Some or all of these units may be selected to achieve the purpose of this embodiment according to actual needs.

[0308] In addition, the functional units in the various embodiments of the present application may be integrated into a single processing unit, or each unit may exist physically separately, or two or more units may be integrated into a single unit. The aforementioned integrated units may be implemented in the form of hardware or software functional units.

[0309] The above is only a preferred embodiment of the present application. It should be pointed out that for ordinary technicians in this technical field, several improvements and modifications can be made without departing from the principles of the present application. These improvements and modifications should also be regarded as the scope of protection of the present application.

Claims

1. A method for processing model data, characterized in that: include: In response to a model training request sent by a server, performing training based on local training data and initial model parameters to obtain local model parameters and link state information, and sending the link state information to the server, wherein the model training request includes the initial model parameters; Receiving a maximum communication loop determined by the server based on the link state information, wherein the maximum communication loop represents a communication path that passes through each of M clients a number of times that satisfies a preset number condition and where M has a maximum value, where M is a positive integer; The local model parameters corresponding to other clients except the client itself are sequentially obtained according to the maximum communication loop, and are aggregated to generate global model parameters.

2. The method according to claim 1, characterized in that The step of sequentially acquiring the local model parameters corresponding to other clients except the client itself according to the maximum communication loop and aggregating them to generate global model parameters includes: Dividing the local model parameters into M blocks based on the number of clients in the maximum communication loop; Distributed accumulation and synchronization are performed on the M blocks in sequence according to the maximum communication loop to generate the global model parameters.

3. The method according to claim 2, characterized in that The performing distributed accumulation and synchronization on the M blocks in sequence according to the maximum communication loop to generate the global model parameters includes: Based on the maximum communication loop, the blocks received from the previous client are summed with the block of the current client, and the updated block is sent to the next client. This is repeated M-1 times to obtain intermediate model parameters. Based on the maximum communication loop, the intermediate model parameters received from the previous client are used to replace the intermediate model parameters stored in the self-stored intermediate model parameters, and the process is repeated M-1 times to generate the global model parameters.

4. The method according to claim 1, wherein The method further comprises: Determining a model metric parameter threshold based on the model training request; After training based on the local training data and the initial model parameters, determining current model metric parameters; Determining whether to end training based on a comparison result of the model metric parameter threshold and the current model metric parameter; When it is determined that the training needs to be terminated, the global model parameters are sent to the server.

5. A method for processing model data, characterized in that: include: Sending a model training request to the client, wherein the model training request includes initial model parameters; Receiving link state information sent by the client, wherein the link state information represents information obtained by the client through training based on local training data and the initial model parameters; Determining a maximum communication loop based on the link state information, wherein the maximum communication loop represents a communication path that passes through each of the M clients a number of times that satisfies a preset number condition and where M has a maximum value, where M is a positive integer; The global model parameters uploaded by the client are received, wherein the global model parameters represent model parameters generated by aggregating local model parameters corresponding to other clients except the client itself obtained in sequence according to the maximum communication loop.

6. The method according to claim 5, characterized in that The determining of the maximum communication loop based on the link state information includes: Build a network topology map based on a predetermined set of clients; Determining the connection status between the clients in the network topology graph based on the link status information; The maximum communication loop is determined according to the network topology diagram and the connection status.

7. The method according to claim 6, characterized in that The determining of the maximum communication loop based on the link state information includes: Randomly select a client as an initial node from the network topology graph and construct a path record structure; Starting from the initial node, recursively explore each unvisited neighbor node based on the link state information, and the neighbor node explored each time is regarded as the current node; Determining whether the current node meets a termination condition by marking the current node as visited and adding the node to the end of the path record structure; If the current node does not meet the termination condition, reselecting a node marked as unvisited among the adjacent nodes of the current node as the current node and re-exploring until the traversal is completed; When the current node satisfies the termination condition, the maximum communication loop is generated.

8. The method according to claim 7, characterized in that The determining whether the current node satisfies the termination condition by marking the current node as a visited state and adding the node to the end of the path record structure includes: When the total number of nodes in the path record structure is equal to the total number of nodes in the network topology graph and the first and last nodes coincide, a valid loop is generated; In the case where the length of the effective loop exceeds the historical maximum value, determining that the termination condition is met, and updating the effective loop to the maximum communication loop; When all the adjacent nodes of the current node are marked as the visited state or the valid cycle is not found, the current node is removed from the end of the path record structure and the access state of the current node is reset.

9. The method according to claim 7, characterized in that The determining whether the current node satisfies the termination condition by marking the current node as a visited state and adding the node to the end of the path record structure includes: When the total number of nodes in the path record structure is equal to the total number of nodes in the network topology graph and the first and last nodes coincide, a valid loop is generated; When the length of the valid loop exceeds a historical maximum value, determining a sum of weights of each edge in the valid loop, wherein the weight of each edge is used to indicate a communication rate of each edge; When the sum of the weights of the edges in the valid loop exceeds a historical maximum value, determining that the termination condition is satisfied, and updating the valid loop to the maximum communication loop; When all the adjacent nodes of the current node are marked as the visited state or the valid cycle is not found, the current node is removed from the end of the path record structure and the access state of the current node is reset.

10. A model data processing device, characterized in that: include: a training module, configured to respond to a model training request sent by a server, perform training based on local training data and initial model parameters, obtain local model parameters and link state information, and send the link state information to the server, wherein the model training request includes the initial model parameters; a first receiving module, configured to receive a maximum communication loop determined by the server based on the link state information, wherein the maximum communication loop represents a communication path in which the number of times passing through each of M clients satisfies a preset number condition and the value of M is the largest, where M is a positive integer; A generation module is used to sequentially obtain the local model parameters corresponding to other clients except itself according to the maximum communication loop, aggregate them, and generate global model parameters.

11. A model data processing device, characterized in that: include: A sending module, configured to send a model training request to a client, wherein the model training request includes initial model parameters; A second receiving module is configured to receive link state information sent by the client, wherein the link state information represents information obtained by the client through training based on local training data and the initial model parameters; a determination module configured to determine a maximum communication loop based on the link state information, wherein the maximum communication loop represents a communication path that passes through each of M clients a number of times that satisfies a preset number condition and where M has a maximum value, where M is a positive integer; The third receiving module is used to receive the global model parameters uploaded by the client, wherein the global model parameters represent model parameters generated by the client aggregating the local model parameters corresponding to other clients except itself obtained in sequence according to the maximum communication loop.

12. A computer-readable storage medium, characterized in that The computer-readable storage medium stores a computer program, wherein when the computer program is executed by a processor, the steps of the method according to any one of claims 1 to 4 are implemented, or the steps of the method according to any one of claims 5 to 9 are implemented.

13. A computer program product comprising a computer program / instructions, characterized in that When the computer program / instructions are executed by a processor, the steps of the method according to any one of claims 1 to 4 are implemented, or the steps of the method according to any one of claims 5 to 9 are implemented.

14. An electronic device comprising a memory, a processor, and a computer program stored in the memory and executable on the processor, wherein: When the processor executes the computer program, the processor implements the steps of the method according to any one of claims 1 to 4, or implements the steps of the method according to any one of claims 5 to 9.

Images