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

Abstract

The application discloses a model data processing method and device, a storage medium and an electronic device. 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; receiving a maximum communication loop determined by the server according to the link state information, wherein the maximum communication loop represents a communication path with the maximum value of M, wherein M is a positive integer, and the number of times of passing through each client in M clients meets a preset number condition; and aggregating local model parameters corresponding to other clients except itself in sequence according to the maximum communication loop to generate global model parameters. The application solves the technical problem that the instability of communication between the client and the server leads to difficulty in guaranteeing the efficiency of model training.

Description

Technical Field

[0001] This application relates to the field of computers, and more specifically, to a method and apparatus for processing model data, a storage medium, and an electronic device. Background Technology

[0002] As a core component of global communication infrastructure, satellite internet's low-Earth orbit (LEO) satellite constellations have accumulated a vast amount of user location, communication traffic, and satellite status data through multi-satellite networking. This data is invaluable for driving the intelligent transformation of satellite internet, but intelligent processing must be achieved while ensuring data privacy and security. Federated learning technology has been introduced into this field, allowing multiple satellite clients to collaboratively train artificial intelligence models without sharing raw data.

[0003] The relevant technologies generally adopt a centralized federated learning framework: satellites, acting as clients, train models using local data, then upload the local model parameters to a ground-based central server for aggregation, generating a global model which is then distributed to each satellite. This architecture has significant drawbacks: First, the concentrated transmission of a large number of model parameters to a single central node within a short period can easily cause network congestion, exceeding the bandwidth limitations of the satellite-to-ground link; second, due to the short communication window between satellites and ground stations, waiting for all satellites to complete model uploads consumes a significant amount of time; finally, the central server is susceptible to single-point failure, and its failure will interrupt the entire training process. Although some improved solutions attempt to optimize efficiency through hierarchical aggregation or asynchronous mechanisms, they still cannot solve the problem of intermittent interruptions in inter-satellite links caused by the high-speed movement of satellites, resulting in unreliable model interaction and aggregation processes.

[0004] Therefore, federated learning for low-Earth orbit satellite constellations faces the technical problem of difficulty in guaranteeing the training efficiency of model parameters due to the dynamic instability of inter-satellite links.

[0005] There is currently no effective solution to the above problems. Summary of the Invention

[0006] This application provides a method and apparatus for processing model data, a storage medium, and an electronic device to at least solve the technical problem that unstable communication between the client and the server makes it difficult to guarantee the efficiency of model training.

[0007] According to one aspect of the embodiments of this application, a method for processing model data is provided, comprising: responding 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, wherein the model training request includes the initial model parameters; receiving the maximum communication loop determined by the server according to the link state information, wherein the maximum communication loop represents the communication path that passes through each of M clients a number of times satisfying a preset number condition, and M is the largest value, where M is a positive integer; and sequentially obtaining the local model parameters corresponding to other clients (excluding itself) according to the maximum communication loop and aggregating them to generate global model parameters.

[0008] According to another aspect of the embodiments of this 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 the maximum communication loop based on the link status information, wherein the maximum communication loop represents the communication path that passes through each of M clients the number of times it satisfies a preset number condition, and M is the largest value, where M is a positive integer; and 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 (excluding itself) sequentially according to the maximum communication loop.

[0009] According to another aspect of the embodiments of this application, a model data processing apparatus is also provided, comprising: 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 to 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 the maximum communication loop determined by the server according to the link state information, wherein the maximum communication loop represents the communication path that passes through each of M clients a number of times satisfying a preset number condition, and M is the largest value, where M is a positive integer; and a generation module, configured to sequentially obtain the local model parameters corresponding to other clients besides itself according to the maximum communication loop, aggregate them, and generate global model parameters.

[0010] In an exemplary embodiment, the device is configured to aggregate the local model parameters corresponding to other clients besides itself according to the maximum communication loop in the following manner to generate global model parameters: the local model parameters are divided into M blocks based on the number of clients in the maximum communication loop; the M blocks are distributedly accumulated and synchronized according to the maximum communication loop to generate the global model parameters.

[0011] In an exemplary embodiment, the device is configured to generate the global model parameters by performing distributed accumulation and synchronization on the M blocks sequentially according to the maximum communication loop in the following manner: based on the maximum communication loop, the device sequentially sums the block received from the previous client with its own block, and sends the updated block to the next client, repeating this process M-1 times to obtain intermediate model parameters; based on the maximum communication loop, the device replaces its own stored intermediate model parameters with the intermediate model parameters received from the previous client, repeating this process M-1 times to generate the global model parameters.

[0012] In an exemplary 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 training based on a comparison result between the model metric parameter threshold and the current model metric parameter; and send the global model parameters to the server if it is determined that training needs to be ended.

[0013] According to another aspect of the embodiments of this application, a model data processing apparatus is also provided, comprising: a sending module, configured to send a model training request to a client, the model training request including initial model parameters; a second receiving module, configured to receive 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; a determining module, configured to determine the maximum communication loop based on the link status information, wherein the maximum communication loop represents the communication path that passes through each of M clients the number of times it satisfies a preset number condition, and M is the largest value, where M is 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 the local model parameters corresponding to other clients (excluding itself) sequentially according to the maximum communication loop.

[0014] In an 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 the connection status between clients in the network topology graph based on the link state information; and determining the maximum communication loop based on the network topology graph and the connection status.

[0015] In an exemplary embodiment, the apparatus is configured to determine the maximum communication loop based on the link state information in the following manner: randomly selecting a client as an initial node from the network topology graph and constructing a path record structure; recursively exploring each unvisited neighbor node based on the link state information starting from the initial node, with each explored neighbor node being regarded as the current node; determining whether the current node meets a termination condition by marking the current node as visited and adding it to the end of the path record structure; if the current node does not meet the termination condition, reselecting the unvisited nodes among the current node's neighbor nodes as the current node and re-exploring until traversal is complete; and generating the maximum communication loop if the current node meets the termination condition.

[0016] In an exemplary embodiment, the device is configured to 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 in the following manner: if the total number of nodes in the path record structure is equal to the total number of nodes in the network topology and the first and last nodes overlap, a valid loop is generated; if 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 all 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.

[0017] In an exemplary embodiment, the apparatus is configured to 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 in the following manner: if the total number of nodes in the path record structure is equal to the total number of nodes in the network topology and the first and last nodes overlap, a valid loop is generated; if the length of the valid loop exceeds the historical maximum value, the sum of the weights of each edge in the valid loop is determined, wherein the weights of each edge are used to indicate the communication rate of each edge; if the sum of the weights of each edge in the valid loop exceeds the historical maximum value, the termination condition is determined to be met, and the valid loop is updated to the maximum communication loop; wherein, when all 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.

[0018] According to another aspect of the embodiments of this application, a computer-readable storage medium is also provided, wherein a computer program is stored in the computer-readable storage medium, and the computer program is configured to execute the above-described model data processing method at runtime.

[0019] According to another aspect of the embodiments of this application, a computer program product or computer program is provided, which 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 executes the computer instructions, causing the computer device to perform the processing method for the model data described above.

[0020] According to another aspect of the embodiments of this application, an electronic device is also provided, including a memory and a processor, wherein the memory stores a computer program, and the processor is configured to execute the above-described model data processing method through the computer program.

[0021] In this embodiment, a client-side local training and link status reporting mechanism is adopted. Through a decentralized interaction strategy that dynamically constructs the maximum communication loop on the server, the goal of efficiently adapting to the dynamic changes of inter-satellite links is achieved. This results in a significant improvement in the reliability of federated learning model aggregation, thereby solving the technical problem that unstable communication between the client and the server makes it difficult to guarantee the efficiency of model training. Attached Figure Description

[0022] The accompanying drawings, which are included to provide a further understanding of this application and form part of this application, illustrate exemplary embodiments and are used to explain this application, but do not constitute an undue limitation of this application. In the drawings:

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

[0024] Figure 2 This is a flowchart illustrating an optional model data processing method according to an embodiment of this application;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

[0042] Figure 20 This is a schematic diagram of the structure of another optional model data processing device according to an embodiment of this application. Detailed Implementation

[0043] To enable those skilled in the art to better understand the present application, the technical solutions in the embodiments of the present application will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are only some embodiments of the present application, and not all embodiments. Based on the embodiments in the present application, all other embodiments obtained by those of ordinary skill in the art without creative effort should fall within the scope of protection of the present application.

[0044] It should be noted that the terms "first," "second," etc., in the specification, claims, and accompanying drawings of this application are used to distinguish similar objects and are not necessarily used to describe a specific order or sequence. It should be understood that such data can be interchanged where appropriate so that the embodiments of this application described herein can be implemented in orders other than those illustrated or described herein. Furthermore, the terms "comprising" and "having," and any variations thereof, are intended to cover non-exclusive inclusion; for example, a process, method, system, product, or apparatus that comprises a series of steps or units is not necessarily limited to those steps or units explicitly listed, but may include other steps or units not explicitly listed or inherent to such processes, methods, products, or apparatus.

[0045] First, some nouns or terms that appear in the description of the embodiments of this application shall be interpreted as follows:

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

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

[0048] According to one aspect of the embodiments of this application, a method for processing model data is provided. Optionally, in this embodiment, the above-described method for processing model data can be applied to, for example... Figure 1 The hardware environment shown consists of server 101 and terminal device 103. For example... Figure 1 As shown, server 101 is connected to terminal device 103 via a network and can be used to provide services to terminal device or application 107 installed on terminal device. The application can be video application, instant messaging application, browser application, educational application, game application, etc. Database 105 can be set up on the server or independently of the server to provide data storage services for server 101, such as a game data storage server. The network mentioned above can include, but is not limited to, wired networks and wireless networks. The wired network includes local area networks, metropolitan area networks, and wide area networks. The wireless network includes Bluetooth, WIFI, and other networks that enable wireless communication. Terminal device 103 can be a terminal configured with an application, and can include, but is not limited to, at least one of the following: mobile phones (such as Android phones, iOS phones, etc.), laptops, tablets, handheld computers, MID (Mobile Internet Devices), PADs, desktop computers, smart TVs, smart voice interaction devices, smart home appliances, vehicle terminals, aircraft, virtual reality (VR) terminals, augmented reality (AR) terminals, mixed reality (MR) terminals, and other computer devices. The server mentioned above can be a single server, a server cluster composed of multiple servers, or a cloud server.

[0049] Combination 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 respectively, or by the terminal device and the server together.

[0050] The above is merely an example, and this embodiment does not impose any specific limitations.

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

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

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

[0054] S206: Obtain the local model parameters corresponding to other clients besides itself in sequence according to the largest communication loop, and generate global model parameters.

[0055] Alternatively, as an optional implementation, such as Figure 3 As shown, taking the server as the execution entity as an example, the processing methods for the above model data include:

[0056] S302, Send a model training request to the client. The model training request includes the initial model parameters.

[0057] S304, Receive link status information sent by the client, wherein the link status information represents the information obtained by the client based on local training data and initial model parameters;

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

[0059] S308, receive global model parameters uploaded by the client. The global model parameters represent the model parameters generated by the client sequentially obtaining the local model parameters of other clients (excluding itself) according to the maximum communication loop.

[0060] Optionally, in this embodiment, the aforementioned model training request may include, but is not limited to, a distributed training instruction initiated by the server to the client, which includes initializing 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 a Long Short-Term Memory (LSTM) neural network to a selected satellite node, along with constraints such as an upper limit on the number of training rounds and a convergence threshold. This includes, but is not limited to, the model training triggering mechanism of the Network Data Analytics Function (NWDAF) element in the 3rd Generation Partnership Project (3GPP standard), or the parameter pre-configuration scenario of a satellite orbit calculation model.

[0061] Optionally, in the embodiments of this application, the aforementioned link status information may include, but is not limited to, datasets characterizing the real-time performance of inter-satellite communication links, covering dynamic indicators such as link connectivity, transmission delay, and bandwidth availability. For example, satellites periodically report the signal-to-noise ratio, bit error rate, and available time window of their ISL (inter-satellite link) with adjacent nodes in / outside the orbital plane. This includes, but is not limited to, link quality matrices based on Time Division Multiple Access (TDMA) mechanisms, or link stability assessment data considering Doppler shift compensation.

[0062] Optionally, in this embodiment, the aforementioned maximum communication loop may include, but is not limited to, the unidirectional communication path covering the most nodes constructed in the satellite network topology, which must satisfy the condition that each node is accessed only once. For example, a 7-node loop can be generated in a constellation of 9 satellites using a depth-first search algorithm: satellite node 1 → satellite node 2 → satellite node 3 → satellite node 4 → satellite node 5 → satellite node 6 → node 7. This includes, but is not limited to, the weighted longest path considering link weights, or a redundant loop topology that supports fault tolerance.

[0063] Optionally, in this embodiment, the global model parameters may include, but are not limited to, global model parameters obtained by aggregating other client model data sets acquired through decentralized interaction. For example, satellite node 1 receives model blocks from satellite nodes 2, 3, and 4 sequentially via the Ring AllReduce protocol, reassembles the resulting pre-aggregation parameter matrix, and then performs the aggregation operation to obtain the global model parameters. The pre-aggregation parameter matrix includes, but is not limited to, gradient tensor slices or partitions of model weight vectors.

[0064] In an exemplary embodiment, when a satellite client (such as a low-Earth orbit satellite deploying a Network Data Analytics Function (NWDAF)) receives a model training request from a ground server, it first parses the initial model parameters (such as the weight matrix of a convolutional neural network) in the request. Then, it performs forward and backward propagation calculations using locally stored sensor data (such as multispectral images acquired by the satellite payload) to generate updated local model parameters. Simultaneously, it monitors the inter-satellite link status with adjacent satellites (such as the signal-to-noise ratio fluctuations of Ku-Archaicband (Ka-band) links), encapsulates the trained local model evaluation metrics (such as loss function values) and link quality data into a status report, and transmits it to the ground server via a directional antenna.

[0065] After integrating the link status information reported by all satellites, the server constructs a weighted topology graph with satellites as vertices and available links as edges. Graph theory algorithms (such as an improved depth-first search (DFS)) are used to solve for the single-loop path covering the most nodes, ensuring that the loop length is maximized and nodes are not visited repeatedly. This loop must satisfy preset physical constraints, and finally, the loop node sequence is broadcast to the constellation network.

[0066] Based on the received loop path information, the satellite client initiates model parameter exchange in a predetermined order (e.g., clockwise). A block transmission mechanism is used to divide the local model parameters into M data blocks (M being the number of loop nodes). The specified blocks are sent to the next node via the inter-satellite laser link, while simultaneously receiving block data from the previous node. After M-1 rounds of iterative exchange, each client obtains the complete model parameter set from all other clients.

[0067] The client performs aggregation operations on the local model parameters and the acquired external parameters. Typical approaches include weighted averaging (e.g., assigning weights based on data volume) or gradient fusion. The aggregated global model parameters are then synchronously updated to the local model library for use in the next round of training or real-time inference.

[0068] It should be noted that the communication topology construction can adopt various optimization strategies: in the topology dimension, it can be expanded into a multi-ring parallel structure (such as dividing into sub-rings according to the orbital plane); in the link evaluation dimension, reinforcement learning can be introduced to dynamically adjust the weight coefficients (such as prioritizing links with low elevation angles); in the aggregation algorithm dimension, hierarchical aggregation mechanisms other than federated averaging can be supported (such as first aggregating within the orbital plane and then merging across planes). All modifications to the above implementation methods fall within the protection scope of this solution, and this application does not specifically limit them.

[0069] Through the embodiments of this application, a client-side local training and link status reporting mechanism is adopted, and a decentralized interaction strategy that dynamically constructs the maximum communication loop on the server is used to achieve the goal of efficiently adapting to the dynamic changes of inter-satellite links. This achieves the technical effect of significantly improving the reliability of federated learning model aggregation, and solves the technical problem that unstable communication between the client and the server makes it difficult to guarantee the efficiency of model training.

[0070] As an optional approach, local model parameters corresponding to other clients (excluding the client itself) are obtained sequentially according to the longest communication loop to generate global model parameters, including:

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

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

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

[0074] Optionally, in the embodiments of this application, the aforementioned distributed accumulation may include, but is not limited to, step-by-step aggregation calculations performed on the inter-satellite 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 its local corresponding block, including but not limited to gradient accumulation or weight fusion operations.

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

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

[0077] S1, Block partitioning 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 cyclic order; during each round of transmission: a block with a specified sequence number is sent to the next node, while simultaneously receiving a block sent by the previous node; upon receiving, the accumulation operation is executed immediately;

[0079] S3, All-Gather Phase: After accumulation is complete, M-1 rounds of data exchange are initiated; during transmission, accumulation is not performed, and the target block is directly replaced.

[0080] S4, Target parameter generation: Reassemble all blocks after completing all synchronization phases (All-Gather);

[0081] Example: Navigation satellites will sequentially assemble the recombined blocks to form a parameter set containing all satellite training results.

[0082] It should be noted that the synchronization mechanism has several implementation variations: non-uniform partitioning can be supported at the block division level; parallel pipelines can be used at the transmission protocol level; and tree aggregation can be used instead of aggregation algorithms. All changes to the above implementation methods fall within the scope of this solution, and this application does not specifically limit them.

[0083] Through the embodiments of this application, block transmission avoids large single file transfers, adapts to inter-satellite link bandwidth limitations, and only requires retransmission of a portion of the data (approximately 1 / M of the total data) if a single block transmission fails. Accumulation operations are distributed across multiple nodes, alleviating the computational pressure on a single satellite. The circular pipeline transmission ensures that synchronization time is linear rather than exponentially related to the number of nodes. This significantly improves the practicality of federated learning for low-Earth orbit satellites, providing a technical foundation for critical tasks such as real-time updates of space target recognition models and global weather prediction models. Compared to traditional centralized aggregation, communication load is significantly reduced, while simultaneously improving task completion rates in highly dynamic link environments.

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

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

[0086] Based on the maximum communication loop, the intermediate model parameters stored in the current model are replaced with the intermediate model parameters sent by the previous client. This process is repeated M-1 times to generate global model parameters.

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

[0088] Optionally, in the embodiments of this application, the aforementioned intermediate model parameters may include, but are not limited to, transitional model data that has completed partial aggregation. For example, block combinations formed after multiple rounds of accumulation, including but not limited to temporary parameter snapshots with version tags.

[0089] Optionally, in the embodiments of this application, the above parameter replacement may include, but is not limited to, operations that directly overwrite local data during the synchronization phase. For example, the satellite replaces the corresponding local block copy with the received complete block data, including but not limited to an atomic replacement mechanism with verification.

[0090] In one exemplary embodiment, the satellite client performs the following two-stage synchronization operation:

[0091] Phase 1: Distributed Accumulation (Scatter-Reduce):

[0092] Operating procedures:

[0093] S1, start transmission in loop sequence.

[0094] S2, each satellite performs the following: receiving the block with the specified sequence number sent by the preceding node; summing the received block element by element with the corresponding local block; and sending the updated block to the succeeding node.

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

[0096] Phase 2: All-Gather

[0097] Operating procedures:

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

[0099] S2, each satellite performs the following actions: receives the complete block from the preceding node; directly replaces the corresponding local block (without performing calculations); and forwards the new block to the successor node.

[0100] S3, repeat M-1 rounds.

[0101] It should be noted that this mechanism has room for optimization in multiple dimensions: in terms of block partitioning, it can support dynamic block division (such as adjusting the block size according to the satellite storage capacity); in terms of transmission order, it can be optimized into a bidirectional pipeline (simultaneously sending and receiving blocks with different sequence numbers); and in terms of aggregation algorithm, it can incorporate sparsity processing (transmitting only important gradients). All modifications to the above implementation methods fall within the scope of protection of this solution, and this application does not specifically limit them.

[0102] Through the embodiments of this application, the instantaneous computing power overload of a single satellite is avoided, the block pipeline transmission significantly improves the bandwidth utilization, intermediate parameters only need to store a single block of data, reducing the onboard memory requirements, and a single transmission failure only requires retransmission of a single block (approximately 1 / M of data), achieving efficient parameter synchronization for federated learning of low-orbit satellites, significantly shortening the model aggregation time of the node constellation, and providing core technical support for tasks such as real-time onboard updates of Earth observation models and space weather early warning models.

[0103] As an optional approach, the above method also includes:

[0104] Determine the threshold of model metric parameters based on the model training request;

[0105] After training based on local training data and initial model parameters, determine the current model metric parameters;

[0106] The decision to end training is based on a comparison between the threshold of the model metric parameter and the current model metric parameter.

[0107] If it is determined that training needs to be terminated, send the global model parameters to the server.

[0108] Optionally, in this embodiment, the threshold values ​​for the aforementioned model metrics may include, but are not limited to, quantitative standards for determining model training convergence, and their setting must consider task requirements and resource constraints. The aforementioned current model metrics may include, but are not limited to, the real-time performance metrics of the local model after this round of training. The aforementioned comparison results may include, but are not limited to, the logical judgment output of real-time metrics and thresholds. The aforementioned global model parameters may include, but are not limited to, the final model data aggregated when training terminates. For example, a neural network file containing training weights for all satellite constellations, including but not limited to encrypted parameter sets with differential privacy processing.

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

[0110] S1, Threshold initialization: The convergence criterion in the parsing model training request (e.g., accuracy ≥ 90%).

[0111] S2, Local Metric Calculation: Evaluate the model using the validation dataset after local training is complete.

[0112] S3, Dynamic Comparison Decision: Real-time comparison of current indicators with preset thresholds.

[0113] S4, Global Model Backhaul: Initiate aggregated model transmission after terminating the decision.

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

[0115] It should be noted that the termination mechanism has room for optimization in multiple dimensions: dynamic adjustment can be supported in the threshold setting dimension; multi-indicator weighted scoring can be integrated in the measurement calculation dimension; and a constellation voting mechanism can be introduced in the decision-making dimension. All modifications to the above implementation methods fall within the scope of protection of this solution, and this application does not specifically limit them.

[0116] Through the embodiments of this application, invalid training rounds are avoided, significantly saving onboard computing resources and extending the satellite's on-orbit lifespan. The training process is dynamically adjusted according to real-time performance, improving the robustness of the model in harsh space environments. A threshold grading mechanism is used to prioritize the return of key models (such as disaster early warning models). Anomalies in single-satellite metrics do not affect global decision-making. Reliability is ensured through cross-validation of neighboring satellite data, significantly improving the practicality of federated learning for low-Earth orbit satellites. This significantly shortens the training cycle for tasks such as marine target monitoring, while ensuring that key models can complete training and return in a short time in emergency situations (such as typhoon warnings).

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

[0118] Construct a network topology based on a pre-determined set of clients;

[0119] Determine the connection status between clients in the network topology diagram based on link state information;

[0120] The maximum communication loop is determined based on the network topology and connection status.

[0121] Optionally, in this embodiment, the aforementioned client set may include, but is not limited to, a group of satellite nodes participating in federated learning tasks, whose members must meet the requirements for data holding capability and computing resources. For example, a subset of satellites in a low-Earth orbit constellation divided by orbital plane, including but not limited to static grouping based on satellite number (ID) sequence or elastic clusters dynamically adjusted according to real-time load.

[0122] Optionally, in the embodiments of this application, the network topology graph described above may include, but is not limited to, a graph structure model representing the communication relationship between satellites, where nodes represent satellite clients and edges represent inter-satellite links. For example, a polar orbit constellation topology containing several nodes (corresponding to several satellites) and several directed edges may be constructed, including but not limited to a weighted graph (where the edge weight is the link rate) or a dynamic graph (updated according to the orbital period).

[0123] Optionally, in the embodiments of this application, the aforementioned connection status may include, but is not limited to, the real-time on / off status and transmission performance indicators of the inter-satellite link. For example, the laser link connectivity matrix (1 indicates availability, 0 indicates interruption) periodically reported by the satellite and additional bit error rate and delay parameters, including but not limited to link stability assessment values ​​predicted based on Kalman filtering.

[0124] Optionally, in the embodiments of this application, the aforementioned maximum communication loop may include, but is not limited to, a unidirectional closed path covering the most satellite nodes, which must satisfy Hamiltonian cycle constraints. For example, a loop path containing several satellites can be found in the topology graph through depth-first search, including but not limited to the K-shortest path optimization scheme that considers link weights.

[0125] In one exemplary embodiment, the satellite client receives the maximum communication loop information from the server. This loop routing server is generated through the following process:

[0126] The server selects available nodes from the constellation based on satellite registration information and resource status to form an initial set. For example, in a constellation of several satellites, after excluding nodes in the shadow region or under maintenance, a valid client set containing several satellites is formed.

[0127] A graph model is built based on a client set, with nodes corresponding to satellite spatial locations (e.g., orbital plane-serial number encoding), and edges initialized according to inter-satellite link design rules. For example, the Walker Delta constellation automatically generates four edges for each node (nodes before and after on the same orbit and the nearest node on the adjacent orbit), forming a regular grid topology framework.

[0128] The real-time link data reported by the satellites is mapped to the edge attributes of the topology graph. For example, when the very high frequency band (Ku-Archaic band, or Ka band) link between satellite A and satellite B is interrupted due to Doppler shift, the weight of the corresponding edge is set to infinity (indicating unavailability).

[0129] The loop with the highest node coverage is searched in the constrained topology graph. An improved depth-first search (DFS) algorithm is used to avoid link interruptions, and path compression is used to optimize the total transmission delay.

[0130] It should be noted that there are several implementation variations for topology construction and loop solving: in the set construction dimension, filtering by data type can be supported; in the topology modeling dimension, a probabilistic graphical model can be used; and in the loop solving dimension, an ant colony algorithm can be introduced to optimize multi-objective paths. All changes to the above implementation methods fall within the protection scope of this solution, and this application does not specifically limit them.

[0131] By dynamically constructing the maximum communication loop, avoiding link interruptions and maximizing participating nodes, training continuity can be maintained 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 required for model synchronization and end-to-end latency. The topology-driven loop construction mechanism can 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 relay pressure of traditional centralized architecture. This allows the low-Earth orbit satellite constellation to still efficiently execute decentralized federated learning tasks under the constraint of highly dynamic changes in inter-satellite links, providing underlying support for on-board intelligent processing (such as real-time space weather prediction and autonomous collision avoidance decision-making).

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

[0133] Randomly select clients as initial nodes from the network topology diagram and construct a path record structure;

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

[0135] By marking the current node as visited and adding it to the end of the path record structure, it is determined whether the current node meets the termination condition;

[0136] If the current node does not meet the termination condition, select the unvisited nodes among the adjacent nodes of the current node as the current node and re-explore until the traversal is completed;

[0137] If the current node meets the termination condition, generate the maximum communication loop.

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

[0139] Optionally, in the embodiments of this application, the path recording structure described above may include, but is not limited to, a dynamic data structure that stores the sequence of loop nodes. For example, a doubly linked list may be used to record the access path of satellite node 1 → satellite node 2 → satellite node 3 in sequence, including but not limited to a stack structure to implement a backtracking mechanism or an array structure to support fast indexing.

[0140] Optionally, in this embodiment, the aforementioned unvisited neighbor nodes may include, but are not limited to, adjacent nodes that have available inter-satellite links with the current satellite but have not joined the path. For example, the neighbors of a satellite node include satellite nodes on the same orbit and satellite nodes on adjacent orbits.

[0141] Optionally, in the embodiments of this application, the above-mentioned termination conditions may include, but are not limited to, the criteria for determining the completion of loop construction. For example, termination may occur when the path contains all satellites or the search depth reaches a preset upper limit, including but not limited to detecting that the path has closed to form a loop or that the remaining nodes cannot be connected.

[0142] In one exemplary embodiment, the process of the server recursively exploring and constructing the maximum communication loop includes the following operations:

[0143] S1. Randomly select a satellite client as the initial node from the network topology graph (e.g., satellite node A deployed on orbital plane A), and create an empty path record structure. Initialize the globally 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. At this time, the path is [A].

[0146] S2-2, Neighbor Node Filtering: Obtain A's unvisited neighbors and exclude nodes with interrupted link connections based on link state information;

[0147] S2-3, Depth Recursion: Select satellite node B as the new current node, recursively execute the mark addition operation, and update the path to [A→B];

[0148] S2-4, Termination Decision: When the path covers all available nodes or there are no available neighbors, compare the current path length with the historical best value and update the maximum loop record.

[0149] S3, backtracking mechanism:

[0150] S3-1, When all of satellite node B's neighbors are unreachable, remove satellite node B from the path and mark it as unvisited, then fall 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, executes repeatedly until all possible path branches have been traversed.

[0153] S4, Loop Generation: When a direct link is detected between the first and last nodes of a path, the closed path forms a communication loop, and the loop scheme with the largest number of nodes covered is output.

[0154] It should be noted that there are multiple implementations of the recursive strategy and termination condition: in the neighbor selection dimension, a priority strategy (preferring nodes connected by high-bandwidth links) can be supported; in the backtracking mechanism dimension, memoized search can be introduced to reduce redundant calculations; in the termination determination dimension, multi-objective optimization (synchronously optimizing loop length and total transmission delay) can be integrated. All modifications to the above algorithm implementations fall within the protection scope of this solution, and this application does not specifically limit them.

[0155] This application's embodiments effectively address the challenge of intermittent inter-satellite link interruptions by adjusting the search path based on real-time link status. A backtracking mechanism avoids full graph traversal, reducing computational complexity and adapting to the computing power constraints of onboard processors. It does not rely on fixed orbital topology and supports loop generation for heterogeneous constellations (satellites with mixed inclination / altitude), ensuring the output loop covers the maximum set of connectable nodes and maximizing the number of participating satellites in each round of federated learning. This allows low-Earth orbit satellite constellations to construct efficient model synchronization paths even under the constraint of highly dynamic inter-satellite link changes, providing fundamental communication guarantees for decentralized federated learning. Compared to traditional static routing planning, it significantly improves model aggregation efficiency while reducing the probability of training interruptions due to link disruptions.

[0156] As an optional approach, 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] A valid loop is generated when the total number of nodes in the path record structure equals the total number of nodes in the network topology and the first and last nodes overlap.

[0158] If the length of the effective loop exceeds the historical maximum value, the termination condition is determined to be met, and the effective loop is updated to the maximum communication loop.

[0159] Specifically, when all 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 the embodiments of this application, the path recording structure described above may include, but is not limited to, a dynamic storage container for the node access sequence during the storage loop construction process. For example, a stack structure may be used to record the satellite node access order, including but not limited to a doubly linked list to achieve fast start and end operations or a tree structure to support branch backtracking.

[0161] Optionally, in the embodiments of this application, the aforementioned effective loop may include, but is not limited to, a closed communication path that satisfies the requirement of being connected end to end and covering multiple nodes.

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

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

[0164] In one exemplary embodiment, the server determines the termination condition for recursive exploration using the following logic:

[0165] S1, Verification of valid loop generation conditions: When the number of nodes in the path record structure is equal to the total number of available satellites in the constellation and there is a physical link between the first and last nodes, a loop validity check is triggered; the spatial locations of the first and last 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 neighboring satellites of the current node have been visited; or if the remaining unvisited nodes cannot connect to the current node (e.g., due to inter-satellite link interruption); execute backtracking operation: remove the satellite node from the end of the path, reset its access status to unvisited; and revert to the previous node to continue exploring other branches.

[0168] It should be noted that there are several implementation variations of the termination determination mechanism: Link quality constraints (e.g., bandwidth of the first and last links > 1Gbps) can be added to the loop verification dimension; multi-objective optimization (synchronous comparison of the number of nodes and path latency) can be introduced to the optimal value update dimension; and partial path retention (e.g., retaining a stable sub-path with 10 consecutive nodes) can be supported in the backtracking strategy dimension. All modifications to the above implementation methods fall within the scope of protection of this solution, and this application does not specifically limit them.

[0169] This application's embodiments ensure the actual transmissibility of loops through end-to-end connectivity verification, avoiding mathematically feasible but physically unreachable invalid paths. It dynamically updates historical optimal solutions, ensuring the loop construction process continuously approaches the global optimum rather than a local optimum. An intelligent backtracking mechanism reduces invalid searches, efficiently completing path planning under the limited computing power of onboard processors. It responds in real-time to changes in link status, and can quickly generate alternative solutions when a node in the optimal loop fails. This significantly improves the model synchronization efficiency of low-Earth orbit satellite constellations in federated learning, significantly reduces the time spent on inter-satellite parameter exchange, and significantly controls the loop computation time of large-scale constellations, providing fundamental support for real-time intelligent processing onboard satellites.

[0170] As an optional approach, 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] A valid loop is generated when the total number of nodes in the path record structure equals the total number of nodes in the network topology and the first and last nodes overlap.

[0172] If the length of the effective loop exceeds the historical maximum, determine the sum of the weights of each edge in the effective loop, where the weight of each edge is used to indicate the communication rate of each edge.

[0173] If the sum of the weights of all edges in a valid loop exceeds the historical maximum value, the termination condition is met, and the valid loop is updated to the maximum communication loop.

[0174] Specifically, when all 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 the embodiments of this application, the aforementioned edge weights may include, but are not limited to, numerical indicators that quantify the transmission performance of inter-satellite links, and their calculation is based on real-time communication status data. For example, the product of the available bandwidth (in Gbps) of a very high frequency band (Ku-Archaic band, or Ka band for short) link and the stability coefficient (in the range of 0-1) may be used as the weight value, including but not limited to considering the reciprocal of the transmission delay or the effective rate after bit error rate compensation.

[0176] Optionally, in the embodiments of this application, the sum of the above weights may include, but is not limited to, the comprehensive evaluation value of the performance indicators of all inter-satellite links on the loop path, including but not limited to the linear combination of the bandwidth product after logarithmic transformation or the reciprocal of the delay.

[0177] Optionally, in this embodiment, the aforementioned historical maximum value may include, but is not limited to, the weights and optimal values ​​recorded during algorithm execution. For example, dynamically storing the current highest weight and record may include, but is not limited to, the optimal values ​​of sub-regions stored on separate orbital planes.

[0178] In one exemplary embodiment, the server adds a weight optimization dimension beyond simply meeting the node count target, including but not limited to the following steps:

[0179] S1, Valid loop generation: When the number of path nodes equals the number of available satellites in the constellation and the beginning and end are connected, loop validity verification is triggered;

[0180] S2, Dual Objective Judgment: Compare the current number of loop nodes with the historical maximum (e.g., 96 nodes in the new loop > 94 nodes in the past); when the number of nodes is equal or better, calculate the total weight of the loop (e.g., ∑bandwidth × stability).

[0181] S3, Termination Condition Upgrade: Only if the following conditions are met simultaneously: Number of nodes ≥ Historical Best and Sum of Weights > Historical Best Weight; Update historical records and store loop solutions;

[0182] S4, Intelligent Backtracking Mechanism: When all neighbors of a node have been visited but no better loop has been formed; remove the end node and reset the state, then backtrack to explore new branches;

[0183] It should be noted that there are multiple implementation methods for weight calculation and judgment strategies: In terms of weight definition, link bit error rate (e.g., 1 / BER) and transmission energy efficiency (bit / Joule) can be integrated; in terms of judgment logic, Pareto optimal solution screening (a balanced solution set of the number of nodes and the sum of weights) can be supported; and in terms of backtracking optimization, simulated annealing algorithms can be introduced to avoid local optima. All modifications to the above implementation methods fall within the scope of protection of this solution, and this application does not specifically limit them.

[0184] Through the embodiments of this application, this multi-objective optimization mechanism brings 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 real-time link characteristics to adapt to changes in inter-satellite communication environments such as rain attenuation and space interference, prioritizing low-power laser links to significantly reduce onboard energy consumption. In the event of a single-point failure in the optimal loop, a suboptimal solution (fewer nodes but higher weights) can seamlessly take over. This achieves synergistic optimization of communication efficiency and model accuracy in low-Earth orbit satellite federated learning, providing a highly reliable communication foundation for tasks such as real-time onboard target recognition and space weather forecasting. Compared to single-objective optimization schemes, the training task completion time is significantly shortened, while reducing the probability of model synchronization failure due to link instability.

[0185] The following specific examples will further explain this application:

[0186] Satellite internet, as a key global communication infrastructure, is developing rapidly. Its core component—the Low Earth Orbit (LEO) satellite constellation—effectively expands the coverage of satellite internet and accumulates rich data resources through networking multiple LEO satellites. As data holders, LEO satellites possess various types of data, including user location, communication traffic, and satellite operational status. This data is crucial for driving the intelligent transformation of satellite internet. However, how to achieve intelligent data processing while protecting data privacy and security has become a pressing challenge. To address this, Federated Learning (FL) has been introduced. It allows multiple data holders (i.e., LEO satellites) to perform in-depth data processing and analysis without sharing the raw data, thereby building efficient artificial intelligence (AI) models and propelling satellite internet towards greater intelligence.

[0187] In the field of satellite internet, traditional federated learning methods based on low-Earth orbit satellite constellations employ a "centralized" learning framework, such as... Figure 4 As shown, this federated learning framework consists of two parts: a federated learning (FL) server and a client.

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

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

[0190] (2) Task Management: Supports the initiation of federated learning training tasks and provides initial FL parameters; supports federated learning model monitoring, and the model monitoring information includes model performance, status, etc.; supports federated learning model performance evaluation, and decides whether to continue or stop the training process based on 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, training a model using its own locally stored data. The trained local model is then uploaded to the ground-based central server (the FL server). Upon 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. This process is repeated until the training termination condition is met.

[0194] To more clearly demonstrate the specific implementation of federated learning in low-Earth orbit satellite networks, this section uses the federated learning mechanism among Network Data Analytics Functions (NWDAFs) in the 3rd Generation Partnership Project (3GPP standard) as an example. Federated learning executes FL model training through a server and multiple clients. Figure 5 The connection structure between multiple NWDAFs used to implement federated learning is given.

[0195] like Figure 5 As shown, the server connects to multiple clients. In a federated learning system for low-Earth orbit satellite networks, the FL server is typically a ground station (such as a gateway station or terrestrial base station). The server can provide functions such as client selection and model aggregation. Clients are satellites with local data that perform model training. Clients can collect data from Network Functions (NFs) or Operation, Administration, and Maintenance Systems (OAM) and train local models through the Model Training Logic Function (MTLF). NFs include Access and Mobility Management Functions (AMF), Session Management Functions (SMF), and Unified Data Management (UDM), among others.

[0196] Based on 3GPP standards Figure 6 The training process for federated learning among multiple NWDAFs is presented.

[0197] S1, FL Client Selection: The FL server selects FL clients that include the 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 client, providing the federated learning parameters required for the client to execute model training. These parameters include initializing the global model and model metrics (such as model accuracy).

[0199] S3, Local Model Training: Each client trains the model provided by the server based on local data, generating a local model.

[0200] S4, Sending Training Results: After the client completes local training, it sends the training results to the server. The training results include local model parameters, model metrics, etc.

[0201] S5, Model Aggregation: After receiving the training results from all clients, the FL server aggregates all local model parameters to generate a global model.

[0202] S6, Model Evaluation: Based on the model metrics provided by the FL client, comprehensively evaluate the model performance to determine whether to terminate training. If training is terminated, step S7 is not executed, and FL training ends.

[0203] S7, Global Model Parameter Distribution: If the federated learning training process continues, the server will send the aggregated global model to the selected client for the next round of FL training.

[0204] Repeat steps S3-S7 until the training termination condition is met (such as the model accuracy reaching a threshold).

[0205] This application proposes a decentralized federated learning scheme for low-Earth orbit satellite constellations. By monitoring the inter-satellite link status in real time, an adaptive decentralized model interaction and aggregation method is designed. In this decentralized federated learning framework, clients can communicate directly to synchronize and aggregate models, eliminating the need for centralized model aggregation via a central server. This alleviates the communication pressure on individual nodes, reduces model transmission latency and bandwidth consumption, and avoids the risk of single points of failure.

[0206] This application provides a decentralized federated learning method for low-Earth orbit satellite constellations. Unlike traditional federated learning frameworks that rely on FL servers for centralized model aggregation, this scheme proposes a decentralized model interaction communication and aggregation mechanism. Each satellite client communicates and collaborates directly to synchronize and aggregate models, thus effectively alleviating communication bottlenecks and avoiding the risk of single points of failure.

[0207] Figure 7 This paper demonstrates the proposed decentralized federated learning framework for low-Earth orbit satellite constellations. In this framework, the server can be a ground station (such as a gateway station, ground base station, etc.) or a specific satellite, while the client is a satellite that holds local data and trains the model. Both the server and the client need to have data collection and analysis capabilities (such as NWDAF network elements).

[0208] Compared to traditional federated learning frameworks, this framework adds the following functionalities to the server:

[0209] Client-side model interaction communication management: Supports the collection of inter-satellite link status information, and formulates and distributes client-side model interaction communication schemes to clients based on the inter-satellite link status information;

[0210] The following features have been 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, sending its own local model to other clients according to the scheme and receiving models from other clients;

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

[0213] Next, the operational process of the decentralized federated learning method for low-Earth orbit satellite constellations proposed in this technical solution will be described in detail, such as... Figure 8 As 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, providing the federated learning parameters required for the client to execute model training. These 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 its local dataset, generating a local model.

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

[0218] S5, Model Evaluation: (e.g.) Figure 9 As shown, 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 scheme in step S7), and then executes steps S6, S7, S8, and S9, ending the training. If the model performance requirements are not met, steps S6, S7, and S8 are executed, step S9 is skipped, and then 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. This scheme defines the communication topology and the communication path between the client, and guides the client to exchange models according to the scheme.

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

[0221] S8, Decentralized Model Interaction and Aggregation: Each client interacts with the model 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 Send: If FL training is stopped, the client sends the final global model to the server.

[0223] If FL training continues, repeat steps 3-8 until the training termination condition is met.

[0224] In summary, the innovation of this invention lies in proposing a decentralized model interaction communication and aggregation scheme for low-Earth orbit satellite constellations. In this scheme, clients do not need to send local model parameters to the server for centralized model aggregation; instead, clients communicate directly with each other to synchronize and aggregate models. Since the data transmitted between the server and clients is very small, the server experiences no communication pressure.

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

[0226] Deterministic nearest neighbor relationships: such as Figure 10 As shown, each satellite maintains inter-satellite links with its four neighboring satellites, meaning two satellites are in the same orbit and two are in adjacent orbits. For example, for satellite S... 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 both within and between orbital planes via inter-satellite links. Solid lines in the diagram represent intra-orbital inter-satellite links, while dashed lines represent inter-plane inter-satellite links.

[0227] Intermittent Inter-Satellite Link Disruptions: Despite deterministic neighbor relationships, inter-satellite links are not continuous and stable due to the high-speed relative motion between adjacent satellites, and may be interrupted intermittently, thus affecting model interactions between clients. For example... Figure 10 As shown, satellite S 11 With S 12 And satellite S 12With S 32 The communication link between them was interrupted.

[0228] To address the issue of intermittent interruptions in inter-satellite links, this application proposes an innovative model interaction communication and aggregation scheme 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 this solution is as follows:

[0229] S1, Low-Earth Orbit Satellite Network Topology Construction: After receiving inter-satellite link status information (including whether the communication link is connected, the communication link speed, etc.) from all satellite clients, the server first constructs the communication network topology G=(V,E), where... It is a set of nodes, representing satellite clients; It is an edge set, representing inter-satellite links. For example... Figure 12 As shown, if an edge (a solid black line with double arrows) exists between two satellite nodes, it means that data transmission can occur between them. If no edge exists between two satellites, it means that the communication link between them is interrupted. Furthermore, each edge can be assigned a corresponding weight (such as the communication link rate).

[0230] S2, Maximum Communication Loop Construction: Based on the constructed network topology graph, the goal is to find a path that passes through as many satellite nodes as possible exactly once and eventually returns to the starting point (this path is the maximum communication loop). Alternatively, based on the communication link weights (rates), the goal is to maximize the sum of the weights (rates) of all edges on the path while ensuring the maximum loop. For the above problem, the solution algorithm 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. This algorithm includes the following key steps:

[0232] S2-1, Starting point selection: Randomly select a node as the starting point. The choice of starting point has no decisive impact on the final result, because the algorithm will perform multiple searches starting from each node to find the globally 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 if 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, then 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, then the maximum loop record is updated.

[0238] S2-3-4 recursively explores 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 has been found, remove the current node from the path record and mark it 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 described above, and the algorithm outputs a communication loop for model interaction: s 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: Assuming that the participants in model aggregation are... There are 1 client, {s1, s2, ..., s3}. M},this The clients form a ring-shaped communication link. The Ring AllReduce algorithm is used to achieve interactive synchronization of the model, ensuring that each client has the model parameters of all other clients. This involves 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, Scatter-Reduce 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, executing the Ring AllReduce algorithm: Similar to Scatter-Reduce, in the All-Gather phase, the satellite also performs M-1 block transmissions and receptions. The difference is that this phase does not require accumulating the received blocks; instead, the received block data directly replaces the original block data. After this phase, each satellite obtains all model parameters from 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. These model parameters are aggregated to generate a global model.

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

[0248] like Figure 13 As shown, consider four low-Earth orbit satellites with NWDAF deployed as FL clients. Each client collects network traffic data from NFs such as Session Management Function (SMF), and the collected local traffic data is represented as follows: . Let represent the traffic data of the nth satellite client during the m-th time interval. The traffic prediction problem is modeled as a time series prediction problem, that is, predicting future network traffic based on historical traffic data. Assume... If the traffic needs to be predicted, then the traffic prediction problem can be described as follows:

[0249] ;

[0250] Where f is the network traffic prediction model, and W are the parameters corresponding to the prediction model. The structure of the network traffic prediction model is as follows: Figure 14 As shown, 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 the raw traffic data, the hidden layers perform in-depth data processing and feature extraction, and the output layer generates the final predicted value based on the processing results of the hidden layers.

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

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

[0253] S1, FL Client Selection: The FL server selects clients that include 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 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 a traffic prediction model based on the collected local data. After training, the local model parameters are obtained. Where k represents the satellite client index, and t represents the epoch of FL training.

[0256] S4, Training Results and Inter-Satellite Link Status Information Transmission: After the client completes local model training, it sends the training results (excluding local model parameters) such as model metrics (e.g., 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 accuracy of the traffic prediction model 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 scheme in step S7). Training ends after steps S6, S7, S8, and S9 are completed. If the model performance requirements are not met, steps S6, S7, and S8 are executed, step S9 is skipped, and then the next round of training begins.

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

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

[0260] S8, decentralized model interaction and aggregation:

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

[0262] S8-1-1, Model parameter segmentation: (e.g., ...) Figure 16 As shown, each satellite divides its model parameters into... Each data block. For example, satellites. Model parameters It was divided into four blocks: a0, a1, a2, and a3.

[0263] S8-1-2, Execute the Scatter-Reduce step of the Ring AllReduce algorithm: (e.g.) Figure 17 As shown, the four satellites need to perform the Scatter-Reduce step three times. During the first Scatter-Reduce step, as... Figure 17 As shown by the middle arrow, satellite s1 sends its first block a0 to its next satellite s2, satellite s1 sends its second block b1 to its next satellite s3, satellite s3 sends its third block c2 to its next satellite s4, and satellite s4 sends its fourth block d3 to its next satellite s1. Each satellite, after receiving the block data from the preceding satellite, adds it to the block data at its corresponding position. Therefore, after the first Scatter-Reduce operation, satellite s2's first block data is updated to a0+b0, satellite s3's second block data is updated to b1+c1, satellite s4's third block data is updated to c2+d2, and satellite s1's fourth block data is updated to a3+d3. The updated block data is then... Figure 17 The data is highlighted with a gray background. Next, the second and third Scatter-Reduce operations are performed, and the final block data on each satellite is shown in the dashed box.

[0264] S8-1-3, Perform the all-gather operation of the Ring AllReduce algorithm: (e.g.) Figure 18As shown, after All-Gather is executed, the block data on each satellite is shown in the dashed box. Each satellite's block contains all the model parameter data of all other satellites.

[0265] S8-2, Model Aggregation: After the interactive synchronization of models is completed, each satellite contains all model parameter data of all other satellites. For example... 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, which is the trained network traffic prediction model.

[0268] If FL training continues, repeat steps S3-S8 until the training termination condition is met.

[0269] It is understood that in the specific embodiments of this application, data such as user information are 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 related data must comply with the relevant laws, regulations and standards of the relevant countries and regions.

[0270] It should be noted that, for the sake of simplicity, the foregoing method embodiments are all described as a series of actions. However, those skilled in the art should understand that this application is not limited to the described order of actions, as some steps may be performed in other orders or simultaneously according to this application. Furthermore, those skilled in the art should also understand that the embodiments described in the specification are preferred embodiments, and the actions and modules involved are not necessarily essential to this application.

[0271] According to another aspect of the embodiments of this application, a model data processing apparatus for implementing the above-described model data processing method is also provided. For example... Figure 19 As shown, the device includes:

[0272] The training module 1902 is used to respond to the model training request sent by the server, train based on local training data and initial model parameters, obtain local model parameters and link state information, and send link state information to the server. The model training request includes the initial model parameters.

[0273] The first receiving module 1904 is used to receive the maximum communication loop determined by the server based on the link status information. The maximum communication loop represents the communication path that passes through each of the M clients the number of times it satisfies the preset number condition, and M is the largest value of M. M is a positive integer.

[0274] The generation module 1906 is used to obtain the local model parameters corresponding to other clients besides itself in sequence according to the maximum communication loop, and generate global model parameters.

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

[0276] As an optional approach, the aforementioned device is used to obtain local model parameters corresponding to other clients besides itself in sequence according to the maximum communication loop in the following manner, and generate global model parameters: the local model parameters are divided 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 global model parameters.

[0277] As an optional approach, the aforementioned device is used to generate global model parameters by performing distributed accumulation and synchronization on M blocks sequentially according to the maximum communication loop in the following manner: 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, repeating this process 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 its own memory, repeating this process M-1 times to generate global model parameters.

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

[0279] According to another aspect of the embodiments of this application, a model data processing apparatus for implementing the above-described model data processing method is also provided. For example... Figure 20 As shown, the device includes:

[0280] Sending module 2002 is used to send a model training request to the client, the model training request including initial model parameters;

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

[0282] The determining module 2006 is used to determine the maximum communication loop based on the link status information, wherein the maximum communication loop represents the communication path that passes through each of the M clients the number of times it satisfies a preset number condition, and the value of M is the largest, 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 the model parameters generated by the client by aggregating the local model parameters corresponding to other clients besides itself in the order of the maximum communication loop.

[0284] As an optional approach, the device is used to determine the maximum communication loop based on the link state information by: constructing a network topology map based on a predetermined set of clients; determining the connection status between clients in the network topology map based on the link state information; and determining the maximum communication loop based on the network topology map and the connection status.

[0285] As an optional approach, the device is used to determine the maximum communication loop based on the link state information in the following manner: randomly selecting a client as an initial node from the network topology graph and constructing a path record structure; recursively exploring each unvisited neighbor node based on the link state information starting from the initial node, with each explored neighbor node being regarded as the current node; determining 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; if the current node does not meet the termination condition, reselecting the unvisited nodes among the current node's neighbor nodes as the current node and re-exploring until traversal is complete; generating the maximum communication loop if the current node meets the termination condition.

[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 visited and adding it to the end of the path record structure in the following manner: if the total number of nodes in the path record structure is equal to the total number of nodes in the network topology and the first and last nodes overlap, a valid loop is generated; if 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 all 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.

[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 visited and adding it to the end of the path record structure in the following manner: if the total number of nodes in the path record structure is equal to the total number of nodes in the network topology and the first and last nodes overlap, a valid loop is generated; if the length of the valid loop exceeds the historical maximum value, the sum of the weights of each edge in the valid loop is determined, wherein the weights of each edge are used to indicate the communication rate of each edge; if the sum of the weights of each edge in the valid loop exceeds the historical maximum value, the termination condition is determined to be met, and the valid loop is updated to the maximum communication loop; wherein, when all 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.

[0288] In the embodiments of this application, the terms "module" or "unit" refer to a computer program or part of a computer program that has a predetermined function and works with other related parts to achieve a predetermined goal, and can be implemented wholly or partially using software, hardware (such as processing circuitry or memory), or a combination thereof. Similarly, a processor (or multiple processors or memory) can be used to implement one or more modules or units. Furthermore, each module or unit can be part of an overall module or unit that includes the functionality of that module or unit.

[0289] Regarding the apparatus in the above embodiments, the specific manner in which each module performs its operation has been described in detail in the embodiments related to the method, and will not be elaborated upon here.

[0290] According to one aspect of this application, a computer program product is provided, comprising a central processing unit (CPU) capable of performing various appropriate actions and processes based on a program stored in read-only memory (ROM) or a program loaded from storage into random access memory (RAM). The RAM also stores various programs and data required for system operation. The CPU, ROM, and 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: input sections including keyboards, mice, etc.; output sections including cathode ray tubes (CRTs), liquid crystal displays (LCDs), and speakers; storage sections including hard drives; and communication sections including network interface cards such as LAN 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 disks, optical discs, magneto-optical discs, semiconductor memories, etc., are installed on the drive as needed so that computer programs read from them can be installed into the storage section as required.

[0292] Specifically, according to embodiments of this application, the processes described in the various method flowcharts can be implemented as computer software programs. For example, embodiments of this application include a computer program product comprising a computer program carried on a computer-readable medium, the computer program containing program code for performing the methods shown in the flowcharts. In such embodiments, the computer program can be downloaded and installed from a network via a communication component, and / or installed from a removable medium. When the computer program is executed by a central processing unit, it performs various functions defined in the system of this application.

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

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

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

[0296] Optionally, in this embodiment, the processor may be configured to execute the methods in the embodiments of this application via a computer program.

[0297] The memory can be used to store software programs and modules, such as the program instructions / modules corresponding to the model data processing method and apparatus in this application embodiment. The processor executes various functional applications and data processing by running the software programs and modules stored in the memory, thereby realizing the aforementioned model data processing method. The memory may include high-speed random access memory, and may also include 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 memory remotely located relative to the processor, and these remote memories can be connected to the terminal via a network. Examples of such networks include, but are not limited to, the Internet, corporate intranets, local area networks, mobile communication networks, and combinations thereof.

[0298] Optionally, the transmission device of the aforementioned electronic device is used to receive or send data via a network. Specific examples of the network may include wired networks and wireless networks. In one example, 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 another example, the transmission device is a Radio Frequency (RF) module used to communicate with the Internet wirelessly.

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

[0300] According to one aspect of this application, a computer-readable storage medium is provided, wherein a processor of an electronic device reads computer instructions from the computer-readable storage medium, and executes the computer instructions, causing the electronic device to perform the model data processing method provided in various alternative implementations of the above-described model data processing aspect.

[0301] Optionally, in this embodiment, the computer-readable storage medium described above may be configured to store methods for performing the embodiments of this application.

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

[0303] The sequence numbers of the embodiments in this application are for descriptive purposes only and do not represent the superiority or inferiority of the embodiments.

[0304] If the integrated units in the above embodiments are implemented as software functional units and sold or used as independent products, they can be stored in the aforementioned computer-readable storage medium. Based on this understanding, the technical solution of this application, in essence, 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. This computer software product is stored in a storage medium and includes several instructions to cause one or more electronic devices to execute all or part of the steps of the methods described in the various embodiments of this application.

[0305] In the above embodiments of this application, the descriptions of each embodiment have different focuses. For parts not described in detail in a certain embodiment, please refer to the relevant descriptions of other embodiments.

[0306] In the several embodiments provided in this application, it should be understood that the disclosed application can be implemented in other ways. The device embodiments described above are merely illustrative; for example, the division of units is only a logical functional division, and in actual implementation, there may be other division methods. For example, multiple units or components may be combined or integrated into another system, or some features may be ignored or not executed. Furthermore, the displayed or discussed mutual couplings, direct couplings, or communication connections may be through some interfaces; indirect couplings or communication connections between units or modules may be electrical or other forms.

[0307] The units described as separate components may or may not be physically separate. 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 the units can be selected to achieve the purpose of this embodiment according to actual needs.

[0308] Furthermore, the functional units in the various embodiments of this application can be integrated into one processing unit, or each unit can exist physically separately, or two or more units can be integrated into one unit. The integrated unit can be implemented in hardware or as a software functional unit.

[0309] The above description is only a preferred embodiment of this application. It should be noted that for those skilled in the art, several improvements and modifications can be made without departing from the principle of this application, and these improvements and modifications should also be considered within the scope of protection of this application.

Claims

1. A method for processing model data, characterized in that, include: In response to a model training request sent by the server, the system trains based on local training data and initial model parameters to obtain local model parameters and link status information, and sends the link status information to the server. The model training request includes the initial model parameters. The server receives the maximum communication loop determined by the link status information, wherein the maximum communication loop represents the communication path that passes through each of the M clients the number of times it satisfies a preset number condition, and M is the largest value of M, where M is a positive integer; The local model parameters corresponding to other clients (excluding itself) are sequentially obtained according to the maximum communication loop and aggregated to generate global model parameters. This includes: 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 on the M blocks sequentially according to the maximum communication loop to generate the global model parameters. This includes: summing the block received from the previous client with its own block based on the maximum communication loop, and sending the updated block to the next client, repeating this process M-1 times to obtain intermediate model parameters; and replacing the intermediate model parameters stored in itself with the intermediate model parameters received from the previous client based on the maximum communication loop, repeating this process M-1 times to generate the global model parameters.

2. The method according to claim 1, characterized in that, The method further includes: Determine the threshold of the model metric parameters based on the model training request; After training based on the local training data and the initial model parameters, the current model metric parameters are determined; Whether to end training is determined based on the comparison result between the model metric parameter threshold and the current model metric parameter; If it is determined that training needs to be terminated, the global model parameters are sent to the server.

3. A method for processing model data, characterized in that, include: Send a model training request to the client, the model training request including initial model parameters; Receive link status information sent by the client, wherein the link status information represents information obtained by the client based on local training data and the initial model parameters; The maximum communication loop is determined based on the link state information, wherein the maximum communication loop represents the communication path that passes through each of the M clients the number of times it satisfies a preset number condition, and M is the largest value of M, where M is a positive integer; Receive 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 (excluding itself) in sequence according to the maximum communication loop; The step of determining the maximum communication loop based on the link state information includes: constructing a network topology graph based on a pre-determined set of clients; determining the connection status between clients in the network topology graph based on the link state information; and determining the maximum communication loop based on the network topology graph and the connection status, including: 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 based on the link state information starting from the initial node, with each explored neighbor node being considered the current node; determining 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; if the current node does not meet the termination condition, reselecting the unvisited nodes among the current node's neighbor nodes as the current node and re-exploring until traversal is complete; and generating the maximum communication loop if the current node meets the termination condition.

4. The method according to claim 3, characterized in that, The step of determining 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 includes: When the total number of nodes in the path record structure is equal to the total number of nodes in the network topology and the first and last nodes overlap, a valid loop is generated. If the length of the effective loop exceeds the historical maximum value, and the termination condition is met, the effective loop is updated to the maximum communication loop. Specifically, when all 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.

5. The method according to claim 3, characterized in that, The step of determining 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 includes: When the total number of nodes in the path record structure is equal to the total number of nodes in the network topology and the first and last nodes overlap, a valid loop is generated. If the length of the effective loop exceeds the historical maximum value, the sum of the weights of each edge in the effective loop is determined, wherein the weights of each edge are used to indicate the communication rate of each edge. If the sum of the weights of all edges in the effective loop exceeds the historical maximum value, the termination condition is determined to be met, and the effective loop is updated to the maximum communication loop. Specifically, when all 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.

6. A device for processing model data, characterized in that, include: The training module is used to respond to a model training request sent by the server, train 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; The first receiving module is used to receive the maximum communication loop determined by the server based on the link status information, wherein the maximum communication loop represents the communication path that passes through each of the M clients the number of times it satisfies a preset number condition, and M is the largest value of M, where M is a positive integer; The generation module is used to sequentially obtain the local model parameters corresponding to other clients besides itself according to the maximum communication loop, aggregate them, and generate global model parameters. This includes: dividing the local model parameters into M blocks based on the number of clients in the maximum communication loop; and sequentially performing distributed accumulation and synchronization on the M blocks according to the maximum communication loop to generate the global model parameters. This includes: sequentially summing the received block sent by the previous client with its own block based on the maximum communication loop, and sending the updated block to the next client, repeating this process M-1 times to obtain intermediate model parameters; and replacing its own stored intermediate model parameters with the received intermediate model parameters sent by the previous client based on the maximum communication loop, repeating this process M-1 times to generate the global model parameters.

7. A device for processing model data, characterized in that, include: The sending module is used to send a model training request to the client, the model training request including initial model parameters; The second receiving module is used to receive link status information sent by the client, wherein the link status information represents information obtained by the client based on local training data and the initial model parameters; The determining module is used to determine the maximum communication loop based on the link status information, wherein the maximum communication loop represents the communication path that passes through each of the M clients the number of times it satisfies a preset number condition, and M is the largest value of M, 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 the model parameters generated by the client by aggregating the local model parameters corresponding to other clients except itself in the order of the maximum communication loop. The determining module is further configured to: construct a network topology graph based on a pre-determined set of clients; determine the connection status between clients in the network topology graph based on the link state information; and determine the maximum communication loop based on the network topology graph and the connection status, including: 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 based on the link state information starting from the initial node, with each explored neighbor node being considered the current node; determining 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; if the current node does not meet the termination condition, reselecting the unvisited nodes among the current node's neighbor nodes as the current node and re-exploring until traversal is complete; and generating the maximum communication loop if the current node meets the termination condition.

8. 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, it implements the steps of the method according to any one of claims 1 to 2, or the steps of the method according to any one of claims 3 to 5.

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

10. An electronic device comprising a memory, a processor, and a computer program stored in the memory and executable on the processor, characterized in that, When the processor executes the computer program, it implements the steps of the method according to any one of claims 1 to 2, or the steps of the method according to any one of claims 3 to 5.

Images