Cross-data-island federated recursive offloading method and system for edge computing

Abstract

The present application relates to the technical field of federated learning, and particularly relates to a cross-data-island federated recursive offloading method and system for edge computing. The method comprises the following steps: constructing a three-layer recursive offloading architecture of an end device-edge server-cloud and combining a cross-data-island federated learning mechanism; calculating a dynamic offloading threshold based on a local historical confidence queue and executing a two-layer recursive offloading decision; performing gradient clipping on a local model update and adopting a secure multi-party computation protocol to perform encrypted segmentation and share reorganization; adding calibrated Gaussian noise to a global aggregation result to realize differential privacy protection; each organization uses a local private test set to perform performance evaluation and only reports a privacy-protected summary statistic; a cross-island federated server calculates a global performance index based on the summary statistic and judges a convergence condition; the method can meet strict privacy requirements, realize collaborative learning, improve model training effect and reduce the risk of privacy leakage.

Description

Technical Field

[0001] This invention relates to the field of federated learning technology, and in particular to a federated recursive offloading method and system for edge computing across data silos. Background Technology

[0002] With the rapid development of the Internet of Things (IoT) and edge computing, an increasing number of computing tasks are migrating from the cloud to edge devices. Edge computing, by performing computations on devices closer to the data source, can significantly reduce network latency, alleviate the load on central servers, and improve data privacy protection. Against this backdrop, recursive offloading technology has emerged. It constructs a three-layer architecture of end device-edge server-cloud, enabling an intelligent scheduling mechanism that dynamically selects the computation level based on task complexity and confidence. Recursive offloading optimizes resource utilization and response speed while ensuring service quality, providing crucial support for edge intelligent services. Federated learning, as a distributed machine learning paradigm, allows multiple participants to collaboratively train models without sharing raw data, offering new possibilities for cross-organizational data collaboration. Federated learning is mainly divided into cross-device mode and cross-data silo mode. Cross-data silo federated learning is particularly suitable for enterprise-level edge computing scenarios, where a few data silos (such as hospitals and financial institutions) possess large amounts of data but cannot directly share it due to privacy and compliance requirements. In this scenario, different organizations can leverage their respective data advantages to collaboratively train more powerful models while meeting strict privacy protection requirements.

[0003] Currently, various technical solutions have been proposed for recursive offloading and privacy protection in federated learning within edge computing. Regarding recursive offloading, existing work mainly focuses on optimizing dynamic offloading strategies within a single organization. For example, confidence-based adaptive offloading methods set confidence thresholds at each layer, offloading the task to a higher layer when the prediction confidence of a lower-level model falls below the threshold. These methods typically use fixed thresholds or adaptive thresholds based on historical data, achieving a balance between accuracy and computational cost to some extent. Some studies have also introduced early exit mechanisms, allowing neural networks to output prediction results in intermediate layers, further reducing computational overhead. In terms of privacy protection in federated learning, mainstream technologies include secure aggregation and differential privacy. Secure aggregation uses encryption protocols (such as homomorphic encryption and secret sharing) to ensure that the server can only obtain the aggregated model updates and cannot access the updates from individual clients. Differential privacy provides formal privacy guarantees for participants by adding calibration noise to model updates. Furthermore, Trusted Execution Environments (TEEs) leverage hardware isolation to provide stronger privacy protection and are commonly used in highly sensitive scenarios such as finance and healthcare. These technologies have been widely used in cross-device federated learning, but they face different challenges in cross-data silo scenarios.

[0004] Existing recursive unloading methods primarily target resource optimization within a single organization, lacking cross-organizational collaboration mechanisms. When different organizations train recursive unloading models independently, differences in data distribution and sample size make it difficult to obtain threshold strategies with strong generalization capabilities. Existing secure aggregation schemes for federated learning mainly focus on the aggregation of model parameters or gradients, lacking efficient secure computational support for the statistical information required for recursive unloading (such as confidence mean, quantiles, histograms, etc.). Existing differential privacy mechanisms are not finely allocated for privacy budgets in cross-data silo scenarios. General solutions typically set the same privacy parameters for all participants, failing to meet the differentiated privacy requirements of different organizations. Existing federated learning evaluation mechanisms usually require evaluating model performance on a shared test set, which may lead to the leakage of sensitive test data in cross-organizational scenarios. Existing solutions struggle to achieve a good balance between privacy protection strength and computational efficiency. Strong privacy protection mechanisms (such as homomorphic encryption) incur significant performance overhead, while lightweight solutions (such as simple noise addition) may not meet enterprise-level privacy requirements.

[0005] Therefore, traditional recursive unloading methods often suffer from insufficient model generalization ability and privacy leakage risks in cross-organizational scenarios because they only perform threshold learning within a single organization and lack cross-organizational collaboration mechanisms. Furthermore, they do not design efficient and secure aggregation and differentiated privacy protection schemes for the confidence statistics required for recursive unloading. Summary of the Invention

[0006] Based on this, in order to solve the above-mentioned technical problems, a recursive unloading method and system for cross-data silo federation oriented to edge computing is provided, which can meet strict privacy requirements while realizing collaborative learning, improving model training effect and reducing the risk of privacy leakage.

[0007] A recursive offloading method for cross-data silo federation in edge computing, the method comprising:

[0008] A three-layer recursive offloading architecture is constructed, consisting of end devices, edge servers, and the cloud. In each round of federated learning training, the cross-island federated servers distribute the current global model parameters to the selected organization clients. Each organization client performs local training based on its local dataset and updates its local model parameters.

[0009] Each organization's client calculates the dynamic offload threshold for the current round based on its local historical confidence queue. When the predicted confidence of the end device is lower than the dynamic threshold at the end device layer, the task is offloaded to the edge server. When the predicted confidence at the edge server layer is lower than the dynamic threshold at the edge server layer, the task is offloaded to the cloud.

[0010] Each of the organization clients performs gradient pruning on the local model update, and then encrypts and divides the pruned model update through a secure multi-party computation protocol to generate shares, which are then distributed to different server aggregators. The server aggregator performs weighted aggregation on the shares of each organization client locally, and restores the global aggregation result through share recombination.

[0011] A calibrated Gaussian noise is added to the global aggregation result to obtain a differentially privacy-preserving global model update. The global model parameters are then updated based on this global model update. Each organization's client uses its local private test set to perform a local performance evaluation of the updated global model and reports privacy-preserving aggregated statistics to the cross-island federation server. The cross-island federation server calculates the global performance index based on the aggregated statistics of each participating organization and determines whether the convergence condition is met. If convergence is not achieved, the next round of training is initiated.

[0012] In one embodiment, a three-layer recursive offloading architecture is constructed, consisting of end devices, edge servers, and the cloud. In each round of federated learning training, the cross-island federated servers distribute the current global model parameters to selected organization clients. Each organization client performs local training based on its local dataset and updates its local model parameters, including:

[0013] The cross-island federation server deploys models at the end device layer, edge server layer, and cloud layer, with each model sharing the same input / output interface; communication links are established between the end device layer and the edge server layer, and between the edge server layer and the cloud layer, and communication overhead parameters and bandwidth parameters are configured to obtain a three-layer recursive offloading architecture;

[0014] The cross-island federation server initializes the three-tier recursive offloading architecture, sets dynamic threshold calculation parameters, and initializes global model parameters.

[0015] At the start of each federation round, the cross-island federation server selects clients from participating organizations and distributes the current global model parameters and the dynamic threshold calculation parameters to the selected organization clients.

[0016] Each of the organization's clients uses the received global model parameters as the initial model parameters for local training, performs forward propagation on its local private dataset, calculates the joint loss function, and calculates the gradient through backpropagation; each of the organization's clients uses the gradient to update its local model parameters.

[0017] In one embodiment, each organization client calculates the dynamic offloading threshold for the current round based on its local historical confidence queue. When the predicted confidence of the end device is lower than the dynamic threshold at the end device layer, the task is offloaded to the edge server; when the predicted confidence at the edge server layer is lower than the dynamic threshold at the edge server layer, the task is offloaded to the cloud, including:

[0018] Each of the organization's clients maintains a confidence history queue at the terminal device layer and the edge server layer, respectively. After each forward inference, the predicted confidence output by the corresponding layer is appended to the end of the corresponding confidence history queue, maintaining a first-in-first-out update to obtain the updated confidence history queue.

[0019] Each of the organization's clients selects the confidence value at the corresponding quantile position from the updated confidence history queue as the dynamic unloading threshold for the current round level, according to the preset quantile parameters.

[0020] When an input sample arrives at the end device, the end device performs inference and outputs the end device layer prediction confidence. If the end device layer prediction confidence is greater than or equal to the end device layer dynamic offloading threshold, the prediction result of the end device layer is used as the final output. If the end device layer prediction confidence is lower than the end device layer dynamic offloading threshold, the input sample is offloaded from the end device to the edge server.

[0021] In one embodiment, when the prediction confidence level of the edge server layer falls below the dynamic threshold of the edge server layer, the task is offloaded to the cloud, including:

[0022] After receiving the unloading sample, the edge server performs inference and outputs the edge server layer prediction confidence. If the edge server layer prediction confidence is greater than or equal to the edge server layer dynamic unloading threshold, the prediction result of the edge server layer is used as the final output; if the edge server layer prediction confidence is lower than the edge server layer dynamic unloading threshold, the unloading sample is unloaded from the edge server to the cloud.

[0023] The cloud platform performs inference on the unloading samples and outputs the final prediction result.

[0024] Each organization's client reports the dynamic offload threshold calculated in this round to the cross-island federation server. The cross-island federation server determines the weight based on the amount of local data of each organization, calculates the global dynamic threshold through weighted quantiles, and distributes the global dynamic threshold to each participating organization's client at the start of the next round of federated learning.

[0025] In one embodiment, each of the organization clients performs gradient pruning on the local model update, and then cryptographically divides the pruned model update using a secure multi-party computation protocol to generate individual shares, which are then distributed to different server aggregators, including:

[0026] Each organization's client calculates the difference between the updated local model parameters and the received global model parameters to obtain the model update increment, and calculates the vector length of the model update increment;

[0027] The vector length is compared with a preset pruning threshold. If it does not exceed the pruning threshold, the model update increment remains unchanged. If it exceeds the pruning threshold, the model update increment is scaled proportionally according to the ratio of the pruning threshold to the current vector length, so that the scaled vector length is equal to the pruning threshold.

[0028] Each organization client randomly divides the trimmed model update vector into shares, each share being randomly distributed in value, and the element-wise sum of all shares equals the original model update vector. Each organization client then sends each share to its respective server aggregator.

[0029] In one embodiment, the server aggregator locally performs weighted aggregation of the shares of each of the organization's clients and restores the global aggregation result through share reorganization, including:

[0030] After receiving the corresponding share from all organization clients, each of the server aggregators determines a weighting coefficient based on the proportion of the local data volume of each organization client to the total data volume of all participating organizations. Locally, all received shares are weighted and summed according to the weighting coefficient to generate a partial aggregation result for each of the server aggregators.

[0031] The cross-island federation server collects the partial aggregation results from all server aggregators and performs element-wise summation. By utilizing the secret-shared additive homomorphic property, the random share introduced by each organization's client during the splitting process is completely canceled out during the cross-server summation process, restoring a global aggregation result equal to the weighted sum of the incremental model updates after each organization's pruning.

[0032] In one embodiment, calibrated Gaussian noise is added to the global aggregation result to obtain a differentially privacy-preserving global model update, and the global model parameters are updated based on the global model update; each organization's client uses a local private test set to perform local performance evaluation of the updated global model, including:

[0033] The cross-island federation server calculates the intensity parameter of Gaussian noise, samples a noise vector from a Gaussian distribution with a mean of zero based on the intensity parameter, adds the noise vector to the global aggregation result to obtain a differential privacy-preserving global model update, and then adds the differential privacy-preserving global model update to the current global model parameters element by element to generate the updated global model parameters.

[0034] The cross-island federation server distributes the updated global model parameters to each participating organization's client through a secure communication channel. Each organization's client loads the updated global model parameters into a local evaluation model, calls a local private test set to perform sample inference on the local evaluation model, compares the model's prediction output with the corresponding real labels to count the number of correct predictions, calculates the local accuracy, and completes the local performance evaluation.

[0035] In one embodiment, a summary statistic on privacy protection is reported to the cross-island federation server. The cross-island federation server calculates a global performance index based on the summary statistics of each participating organization and determines whether the convergence condition is met. If convergence is not achieved, the next round of training is initiated, including:

[0036] Each of the organization's clients calculates the lower and upper limits of the confidence interval for the local accuracy based on the amount of data in the local test set, the local accuracy, and the preset significance level. The local accuracy, the upper and lower limits of the confidence interval are then encapsulated into privacy-preserving summary statistics and reported to the cross-island federation server.

[0037] The cross-island federation server calculates a weighted global performance index based on the aggregated statistics and the amount of local test set data from each organization's clients.

[0038] The cross-island federated server determines whether the convergence condition is met based on the weighted global performance metric and the performance records of the historical rounds. If the convergence condition is not met, the updated global model parameters are used as the starting point for the next round of training to start the next round of federated learning training. If the convergence condition is met, a training completion notification is sent to all participating organization clients, and a privacy consumption report is output.

[0039] A recursive offloading system for cross-data silo federation, oriented towards edge computing, the system comprising:

[0040] A cross-island federation server is used to distribute the current global model parameters to selected organization clients, each of which performs local training based on its local dataset and updates its local model parameters.

[0041] Each of the organization's clients is used to calculate the dynamic offloading threshold for the current round based on the local historical confidence queue. When the predicted confidence of the terminal device is lower than the dynamic threshold of the terminal device layer, the task is offloaded to the edge server; when the predicted confidence of the edge server layer is lower than the dynamic threshold of the edge server layer, the task is offloaded to the cloud.

[0042] The secure multi-party computation aggregator performs gradient pruning on the local model update through the clients of each organization, and then encrypts and divides the pruned model update through a secure multi-party computation protocol to generate shares and distribute them to different server aggregators. The server aggregator performs weighted aggregation on the shares of each client of each organization locally and restores the global aggregation result through share recombination.

[0043] The differential privacy noise injection and local evaluation module is used to add calibrated Gaussian noise to the global aggregation result to obtain a differential privacy-protected global model update, and to update the global model parameters based on the global model update. Each organization's client uses a local private test set to perform local performance evaluation on the updated global model, and reports the privacy-protected summary statistics to the cross-island federation server. The cross-island federation server calculates the global performance index based on the summary statistics of each participating organization and determines whether the convergence condition is met. If convergence is not achieved, the next round of training is started.

[0044] The aforementioned recursive offloading method and system for cross-data silo federation aimed at edge computing constructs a three-layer recursive offloading architecture of end devices, edge servers, and the cloud, combined with a cross-data silo federated learning mechanism. This enables participating organizations to collaboratively train the recursive offloading model without sharing original data, improving the model's inference accuracy and generalization performance in cross-organizational scenarios. A dynamic offloading threshold is calculated based on a local historical confidence queue, balancing inference accuracy and computational resource consumption. Gradient pruning controls the sensitivity upper limit of model updates, and a secure multi-party computation protocol is used to encrypt, segment, and distribute weighted aggregation of the pruned model updates, achieving secure aggregation of model parameters. Adding calibrated Gaussian noise to the global aggregation results ensures that global model updates meet the formal requirements of differential privacy, providing quantifiable privacy guarantees for each organization and enabling effective monitoring of global model performance while protecting test data privacy. Attached Figure Description

[0045] Figure 1 This is an application environment diagram of a recursive offloading method for cross-data silos federation oriented to edge computing in one embodiment.

[0046] Figure 2 This is a flowchart illustrating a recursive offloading method for cross-data silo federation oriented towards edge computing in one embodiment.

[0047] Figure 3 This is a block diagram of a recursive offloading system for cross-data silos federation oriented to edge computing in one embodiment.

[0048] Figure 4 This is a schematic diagram of the application architecture of a recursive offloading method and system for cross-data silos federation oriented towards edge computing in one embodiment.

[0049] Figure 5 This is a schematic diagram of the secure multi-party computation aggregation module structure in one embodiment;

[0050] Figure 6 This is a timing diagram of the cross-island federation training method interaction in one embodiment;

[0051] Figure 7 Here is a flowchart of an enterprise edge intelligence service scenario in one embodiment;

[0052] Figure 8 This is a flowchart of a collaborative analysis scenario for medical data in one embodiment. Detailed Implementation

[0053] To make the objectives, technical solutions, and advantages of this application clearer, the following detailed description is provided in conjunction with the accompanying drawings and embodiments. It should be understood that the specific embodiments described herein are merely illustrative and not intended to limit the scope of this application.

[0054] The cross-data silo federation recursive offloading method for edge computing provided in this application embodiment can be applied to, for example... Figure 1 The application environment shown. For example... Figure 1As shown, the application environment includes interconnected cross-island federated servers 110, organization clients 120, and server aggregators 130. After constructing a three-layer recursive offloading architecture of end devices-edge servers-cloud, in each round of federated learning training, the cross-island federated servers 110 distribute the current global model parameters to the selected organization clients 120. Each organization client 120 performs local training based on its local dataset and updates its local model parameters. Each organization client 120 calculates the dynamic offloading threshold for the current round based on its local historical confidence queue. When the prediction confidence of the end device is lower than the dynamic threshold of the end device layer, the task is offloaded to the edge server. When the prediction confidence of the edge server layer is lower than the dynamic threshold of the edge server layer, the task is offloaded to the cloud. Each organization client 120 updates its local model... Gradient pruning is performed, and the pruned model update is encrypted and divided using a secure multi-party computation protocol. Shares are then distributed to different server aggregators 130. Server aggregators 130 locally weight and aggregate the shares of each organization's client 120, and restore the global aggregation result through share recombination. Calibrated Gaussian noise is added to the global aggregation result to obtain a differentially privacy-preserving global model update, which is used to update the global model parameters. Each organization's client 120 uses its local private test set to perform local performance evaluation of the updated global model and reports privacy-preserving summary statistics to the cross-island federation server 110. The cross-island federation server 110 calculates the global performance index based on the summary statistics of each participating organization and determines whether the convergence condition is met. If convergence is not achieved, the next round of training is initiated.

[0055] In one embodiment, a recursive offloading method for cross-data silos federated across edge computing, referred to as FedSilo, is provided. This method constructs a three-layer recursive offloading architecture: end device – edge server – cloud. It achieves intelligent task scheduling across layers through dynamic confidence threshold learning and employs a cross-data silo federated learning mechanism to enable multiple organizations to collaboratively train the recursive offloading model without sharing raw data. FedSilo comprises three core modules: a recursive confidence offloading module, responsible for dynamically selecting the computation level based on confidence in the three-layer architecture, achieving an optimized balance between computational resources and inference accuracy; a cross-silo federated aggregation module, employing secure multi-party computation technology to securely aggregate model parameters across organizations, enabling each participant to calculate global aggregate statistics without disclosing local model parameters; and a privacy protection and evaluation module, allocating an independent privacy budget to each data silo and using the Rényi differential privacy mechanism to track privacy overhead in multiple training rounds, while also providing a local private test set evaluation mechanism to further protect sensitive information.

[0056] In one embodiment, such as Figure 2As shown, a recursive offloading method for cross-data silo federation oriented towards edge computing is provided, including the following steps:

[0057] Step 202: Construct a three-layer recursive offloading architecture of end device-edge server-cloud. In each round of federated learning training, the cross-island federated server distributes the current global model parameters to the selected organization clients. Each organization client performs local training based on the local dataset and updates the local model parameters.

[0058] First, cross-island federated servers can build a three-tier recursive offloading architecture of end devices-edge servers-cloud, enabling dynamic hierarchical selection based on confidence.

[0059] In one embodiment, a cross-data silo federated recursive offloading method for edge computing may further include the process of constructing a three-layer recursive offloading architecture and performing federated training. Specifically, the process includes: deploying models on the end device layer, edge server layer, and cloud layer respectively on the cross-silo federated server, with each model sharing the same input / output interfaces; establishing communication links between the end device layer and the edge server layer, and between the edge server layer and the cloud layer, and configuring communication overhead and bandwidth parameters to obtain the three-layer recursive offloading architecture; initializing the three-layer recursive offloading architecture on the cross-silo federated server, setting dynamic threshold calculation parameters, and initializing global model parameters; at the beginning of each federated round, the cross-silo federated server selects clients from participating organizations and distributes the current global model parameters and dynamic threshold calculation parameters to the selected organization clients; each organization client uses the received global model parameters as the initial model parameters for local training, performs forward propagation on its local private dataset, calculates the joint loss function, and calculates the gradient through backpropagation; each organization client updates its local model parameters using the gradient.

[0060] The cross-island federated server architecture allows models to be deployed at the end-device layer, edge server layer, and cloud layer, with each model sharing the same input / output interfaces. The end-device layer deploys lightweight models suitable for resource-constrained mobile terminals or IoT devices; the edge server layer deploys medium-sized models suitable for edge nodes with sufficient computing power; and the cloud layer deploys large-scale models, possessing the strongest model expressive power and the highest inference accuracy. Each layer of models receives input data in the same format and dimensions and outputs prediction results and confidence scores in the same format and dimensions. When a model at a certain layer cannot provide sufficiently reliable prediction results, the same input sample can be directly passed to the next layer for further inference.

[0061] Cross-island federated servers can establish communication links between the end device layer and the edge server layer, and between the edge server layer and the cloud, and configure communication overhead parameters and bandwidth parameters to obtain a three-layer recursive offloading architecture. Communication overhead parameters include, but are not limited to, network transmission latency, data transmission energy consumption, and protocol handshake overhead; bandwidth parameters include, but are not limited to, uplink bandwidth and downlink bandwidth.

[0062] The cross-island federated server can randomly initialize the weight parameters of each layer of the model or initialize them based on pre-trained weights; set dynamic threshold calculation parameters, including but not limited to the maximum length of the confidence history queue of the end device layer, the maximum length of the confidence history queue of the edge server layer, the quantile of the end device layer, and the quantile of the edge server layer; and initialize global model parameters, which include the weight parameters of the models at each layer of the end device layer, edge server layer, and cloud layer.

[0063] At the start of each federation round, the cross-island federation server selects some or all of the participating organizations' clients as training clients for that round. The cross-island federation server distributes the global model parameters and dynamic threshold calculation parameters for the current round to the selected organization clients. Each organization client receives these parameters through a secure communication channel and loads them locally as the initial model parameters for training in that round.

[0064] After receiving the global model parameters, each organization's client uses these parameters as the initial model parameters for local training and loads them into its local three-layer recursive unloading model. For each training sample in the local private dataset, the edge device layer model first performs prediction. If the prediction confidence meets the edge device layer's dynamic threshold, inference is completed at the edge device layer. Otherwise, the task is unloaded to the edge server layer for prediction. If the edge server layer's prediction confidence meets the edge server layer's dynamic threshold, inference is completed at the edge server layer. Otherwise, it is further unloaded to the cloud for inference. During the forward propagation process, the prediction results and confidence scores for each sample at each layer are recorded.

[0065] Next, each organization's client calculates the joint loss function based on the results of forward propagation; each organization's client calculates the gradient of the model parameters at each level based on the joint loss function using the backpropagation algorithm; each organization's client uses the gradient to update the local model parameters using the gradient descent algorithm, thus obtaining the local model parameters after this round of training.

[0066] In this embodiment, each organization acts as a client, training its model on local data, while the server securely aggregates model updates from all organizations. Specifically, the standard federated learning training process includes client-side local training, server aggregation, and global model distribution. Each participating organization, Indicates the first Global model parameters of the wheel, Indicates organization The local dataset.

[0067] In federal rounds In the process, the server first selects the set of participating clients. Then the current global model Distribute to these clients. Each selected client Perform local training: ;in, Indicates client The trained local model, Indicates the learning rate. Indicates client The local loss function, This represents the gradient computed on the local dataset.

[0068] For recursive unloading tasks, the local loss function includes not only the prediction accuracy loss but also a computational cost regularization term: ;in, This represents the prediction loss function (such as cross-entropy loss). The model represents the input The prediction This represents the cost regularization coefficient. Indicates sample The computational cost. After the client-side training is complete, the model will be updated. Send to the server. The server uses a secure aggregation protocol to calculate the global update: ;in, Indicates client The local data volume. The server then updates the global model: For the confidence threshold parameter specific to recursive unloading, a quantile aggregation strategy is adopted, making... Indicates client In the The local threshold for each round, and the global threshold, are estimated using weighted quantiles: ;in, This represents the weighted quantile estimation function. Indicates the target quantile.

[0069] Step 204: Each organization's client calculates the dynamic offload threshold for the current round based on its local historical confidence queue. When the predicted confidence of the end device is lower than the dynamic threshold of the end device layer, the task is offloaded to the edge server; when the predicted confidence of the edge server layer is lower than the dynamic threshold of the edge server layer, the task is offloaded to the cloud.

[0070] When the prediction confidence of the low-level model falls below the adaptive threshold, the task is automatically offloaded to a higher level, thereby optimizing the utilization of computing resources and response latency while ensuring inference accuracy.

[0071] In one embodiment, a recursive offloading method for cross-data silo federation in edge computing may include the process of an end device offloading a task to an edge server. Specifically, the process includes: each organization's client maintaining a confidence history queue for both the end device layer and the edge server layer; appending the predicted confidence of the corresponding layer to the end of the corresponding confidence history queue after each forward inference, maintaining a first-in-first-out update to obtain an updated confidence history queue; each organization's client selecting the confidence value at the corresponding quantile position from the updated confidence history queue according to a preset quantile parameter as the dynamic offloading threshold for the current round layer; when an input sample arrives at the end device, the end device performs inference and outputs the end device layer's predicted confidence; if the end device layer's predicted confidence is greater than or equal to the end device layer's dynamic offloading threshold, the prediction result of the end device layer is used as the final output; if the end device layer's predicted confidence is lower than the end device layer's dynamic offloading threshold, the input sample is offloaded from the end device to the edge server.

[0072] In this embodiment, the cross-island federation server can calculate an adaptive threshold using historical confidence statistics, employing a dynamic threshold update strategy based on percentiles. For each layer... Maintain a confidence history queue Its maximum length is When the new confidence score When generated, update the history queue: ;in, Presentation layer The confidence level of the historical set, This indicates the maximum length of the history queue. This represents the newly generated confidence score. Dynamic threshold. Based on historical confidence levels Quantile calculation: ;in, Presentation layer The dynamic threshold, This represents the quantile parameter, which is typically set to around 0.3 to trigger a conservative unloading strategy.

[0073] When entering text Upon arrival at the end device, the end device model first makes a prediction to obtain the predicted label. and confidence level .like Then the task will be offloaded to the edge server: ;in, This is an indicator function that returns 1 when the condition is met, indicating that unloading is triggered.

[0074] In one embodiment, a cross-data silo federated recursive offloading method for edge computing may further include the process of the edge server offloading the task to the cloud. Specifically, the process includes: after receiving the offloading sample, the edge server performs inference and outputs the prediction confidence of the edge server layer. If the prediction confidence of the edge server layer is greater than or equal to the dynamic offloading threshold of the edge server layer, the prediction result of the edge server layer is used as the final output; if the prediction confidence of the edge server layer is lower than the dynamic offloading threshold of the edge server layer, the offloading sample is offloaded from the edge server to the cloud; the cloud performs inference on the offloading sample and outputs the final prediction result; each organization's client reports the dynamic offloading threshold calculated in this round to the cross-data silo federated server; the cross-data silo federated server determines the weights based on the local data volume of each organization, calculates the global dynamic threshold through weighted quantiles, and distributes the global dynamic threshold to each participating organization's client at the start of the next round of federated learning.

[0075] In this embodiment, at the edge server layer, if the confidence level of the edge model... Then it will be further uninstalled to the cloud: The recursive unloading mechanism in this embodiment ensures that only low-confidence difficult examples require higher-level computing resources, thereby achieving a balance between accuracy and efficiency.

[0076] Specifically, in federated learning scenarios, state management needs to support the aggregation of statistical information across organizations while protecting the local data privacy of each organization. Indicates organization The set of states contains the following elements: ;in, and Representing organizations The confidence history of terminal devices and edge layers, This indicates the uninstallation path statistics. Displays cost tracking information. Unload path statistics. Record the frequency of use of different uninstallation paths: ;in, This indicates the number of samples processed only on the end device. This represents the number of samples offloaded from the end device to the edge server. This indicates the number of samples that have undergone three layers of processing.

[0077] Cost tracking Calculate the computation and communication costs for each sample. :;in, and These represent the weighting coefficients for computation and communication costs, respectively. Indicates sample The calculation time, Indicates communication time. The calculation time is determined based on the layer used: ;in, Indicates sample The hierarchical path traversed Indicates hierarchy The unit cost of calculation Indicates the length of the input text. Communication time is calculated based on the uninstallation path. ;in, Indicates hierarchy arrive Fixed communication overhead, This indicates the corresponding bandwidth parameter.

[0078] Step 206: Each organization's client performs gradient pruning on the local model update, and then encrypts and divides the pruned model update through a secure multi-party computation protocol to generate shares, which are then distributed to different server aggregators. The server aggregators perform weighted aggregation of the shares of each organization's client locally, and restore the global aggregation result through share recombination.

[0079] In federated learning scenarios, organizations need to aggregate these statistics to learn the globally optimal threshold strategy, but they cannot directly share the original state data. Therefore, a secure multi-party computation protocol is used to achieve privacy-preserving aggregation of statistics.

[0080] In one embodiment, a recursive offloading method for cross-data silo federation oriented to edge computing may further include a process of secure multi-party computation to generate shares. Specifically, this process includes: each organization's client calculating the difference between the updated local model parameters and the received global model parameters to obtain the model update increment, and calculating the vector length of the model update increment; comparing the vector length with a preset pruning threshold; if the pruning threshold is not exceeded, keeping the model update increment unchanged; if the pruning threshold is exceeded, scaling the model update increment proportionally according to the ratio of the pruning threshold to the current vector length, so that the scaled vector length equals the pruning threshold; each organization's client randomly dividing the pruned model update vector into shares, each share being numerically randomly distributed, and the element-wise sum of all shares equaling the original model update vector; and each organization's client sending each share to its respective server aggregator.

[0081] Each organization's client first calculates the difference between the updated local model parameters and the received global model parameters to obtain the model update increment. The model update increment is a one-dimensional vector, where each element corresponds to the update amount of a trainable parameter in the global model, and its dimension matches the total number of global model parameters. Each organization's client then calculates the vector length of the model update increment, which is the square root of the sum of the squares of all elements in the vector. This vector length represents the overall magnitude of the local model update and reflects the degree of influence of a single organization's training data on the global model.

[0082] Each organization's client compares the vector length with a preset pruning threshold. If the vector length does not exceed the pruning threshold, the model update increment is considered to be within the allowable range, and each organization's client keeps the model update increment unchanged and directly uses it as the pruned model update vector. If the vector length exceeds the pruning threshold, the model update increment is considered to be too large, and each organization's client scales the model update increment proportionally according to the ratio of the pruning threshold to the current vector length, so that the vector length of the scaled model update increment is exactly equal to the pruning threshold, thus obtaining the pruned model update vector.

[0083] After gradient pruning, each organization's client determines the number of server aggregators participating in secure aggregation. The number of server aggregators is configured uniformly across the cross-island federation servers during system initialization. Each organization's client generates an independent random vector for each share. The dimension of each random vector is the same as the pruned model update vector, and the element values ​​follow a preset random distribution, ensuring that each share is numerically random. Each organization's client then sends the generated shares to their respective server aggregators.

[0084] In this embodiment, the secure multi-party computation protocol is based on secret sharing technology, which divides sensitive data into multiple shares and distributes them to different servers. The original data can only be recovered when multiple servers collude. For model aggregation scenarios, let... The model update vector representing the client needs to be safely computed with a weighted sum. ,in These are weighting coefficients. A protocol based on additive secret sharing is used.

[0085] Each client Update your own Randomly divided into Individual shares: ;in, Indicates the number of servers. Indicates the first The share held by each server; each client will be the first The share was sent to the first One server.

[0086] In one embodiment, a recursive offloading method for cross-data silo federation oriented to edge computing may further include a process for restoring the global aggregation result. Specifically, this process includes: each server aggregator receiving the corresponding share from all organizational clients determines a weighting coefficient based on the proportion of each organizational client's local data volume to the total data volume of all participating organizations; locally, it performs a weighted summation of all received shares according to the weighting coefficient, generating a partial aggregation result for each server aggregator; the cross-data silo federation server collects the partial aggregation results from all server aggregators and performs element-wise summation; utilizing the secret-shared additive homomorphic property, the random shares introduced by each organizational client during partitioning are completely canceled out during the cross-server summation process, restoring a global aggregation result equal to the weighted summation of the incremental model updates after each organization's pruning.

[0087] Each server aggregator receives only the share sent by each organization's client. It performs an integrity check on each received share, confirming that the share's dimensions match expectations and the data format is valid. Then, it temporarily stores each organization's client's share in local memory. During system initialization, the cross-island federation server collects the local dataset size reported by each organization's client, calculates the ratio of each organization's client's local data volume to the total data volume of all participating organizations, uses this ratio as the weighting coefficient for that organization's client, and distributes the weighting coefficient configuration to each server aggregator.

[0088] For each organization's client share, the server aggregator multiplies each element of that share by the weight coefficient corresponding to that organization's client, and then sums the weighted shares of all organization clients element by element to obtain the server aggregator's partial aggregation result. After each server aggregator completes its local weighted aggregation, it sends its partial aggregation result to the cross-island federation server. The cross-island federation server collects the partial aggregation results from all server aggregators, and after confirming receipt of the partial aggregation results from all server aggregators, it sums all the partial aggregation results element by element.

[0089] For each organization client, of the N shares generated by its segmentation, the first N minus 1 shares are random vectors, and the Nth share is the original model update vector minus the sum of the first N minus 1 random vectors. When the partial aggregation results of all N server aggregators are summed element-wise, all N shares of that organization client are included in the summation, the random vector parts cancel each other out, and the remaining part is exactly equal to the original pruned model update increment of that organization client multiplied by its weight coefficient. After the above contributions of all organization clients are added together, the final global aggregation result is restored, which is equal to the weighted sum of the pruned model update increments of each organization.

[0090] In this embodiment, the server Calculate local aggregations: All servers will aggregate their respective results. Adding them together, we get the final safe aggregation result: For secure aggregation of scalar statistics such as confidence thresholds, a more efficient protocol should be adopted. Indicates client The scalar value (such as quantile) is used to safely calculate the weighted average. .

[0091] The server can employ a perturbation-based technique: each client Generate random noise Make Then send the perturbation value. Give it to the server. The server calculates: Then the server broadcasts. All clients can perform calculations. This protocol guarantees the value for a single client. It will not be leaked because It concealed their true contributions.

[0092] To prevent malicious clients from using carefully selected... To infer values ​​from other clients, the server can employ a verification protocol, where each client additionally commits to its noise value. The validity of the commitment is verified after aggregation. The commitment mechanism uses a cryptographic hash function: ;in, Represents a hash function. This represents a random salt value, which is then made public by the client after aggregation. and Other client verification .

[0093] Step 208: Add calibrated Gaussian noise to the global aggregation result to obtain a differentially privacy-preserving global model update. Update the global model parameters based on the global model update. Each organization's client uses its local private test set to perform local performance evaluation on the updated global model and reports the privacy-preserving summary statistics to the cross-island federation server. The cross-island federation server calculates the global performance index based on the summary statistics of each participating organization and determines whether the convergence condition is met. If convergence is not achieved, the next round of training is started.

[0094] Federated learning across data silos can offer multi-layered privacy protection mechanisms, including differential privacy noise injection, privacy budget tracking, and local evaluation mechanisms. Specifically, the Rényi Differential Privacy (RDP) accounting method can be used to allocate an independent privacy budget to each organization, ensuring that privacy overhead is controllable during multiple training rounds. It also provides hardware-level privacy enhancement options based on a trusted execution environment to meet the security needs of highly sensitive scenarios.

[0095] In one embodiment, a cross-data silo federation recursive offloading method for edge computing may further include differential privacy protection and performance evaluation processes. Specifically, the process includes: the cross-data silo federation server calculating the intensity parameter of Gaussian noise; sampling a noise vector from a Gaussian distribution with a mean of zero based on the intensity parameter; adding the noise vector to the global aggregation result to obtain a differentially privacy-protected global model update; then adding the differentially privacy-protected global model update element-wise to the current global model parameters to generate updated global model parameters; the cross-data silo federation server distributing the updated global model parameters to each participating organization's client via a secure communication channel; each organization's client loading the updated global model parameters as a local evaluation model and calling a local private test set to perform sample inference on the local evaluation model; comparing the model's predicted output with the corresponding real labels to count the number of correct predictions; calculating the local accuracy; and completing the local performance evaluation.

[0096] The cross-island federation server first calculates the intensity parameter of Gaussian noise, which is the standard deviation of Gaussian noise. Its value is determined based on the independent privacy budget, failure probability and gradient pruning threshold of each organization's client: the noise intensity parameter is directly proportional to the gradient pruning threshold and inversely proportional to the square root of the privacy budget. The smaller the privacy budget, the greater the noise intensity, so as to provide stronger privacy protection.

[0097] The cross-island federated server samples noise vectors from a Gaussian distribution with a mean of zero and a standard deviation equal to the intensity parameter, based on the intensity parameter. The dimension of the noise vector is the same as the dimension of the global aggregation result, and each element in the noise vector independently follows the aforementioned Gaussian distribution. The cross-island federated server adds the noise vector element-by-element to the global aggregation result, resulting in a differentially privacy-preserving global model update.

[0098] After receiving the differential privacy-protected global model update, the cross-island federated server adds the differential privacy-protected global model update element-wise to the current global model parameters to generate the updated global model parameters. These updated global model parameters incorporate the local training knowledge of all participating clients and are protected by the differential privacy mechanism.

[0099] Next, after the global model parameters are updated, each organization's client uses its local private test set to perform local performance evaluation of the updated global model. Specifically, the cross-island federation server distributes the updated global model parameters to each participating organization's client through a secure communication channel. During distribution, the cross-island federation server packages the updated global model parameters and sends them to each organization's client via encrypted transmission, ensuring that the model parameters are not stolen or tampered with during transmission. Each organization's client loads the updated global model parameters as its local evaluation model. During loading, the organization's client writes the global model parameters into its local inference environment and configures the weight parameters of the end device layer, edge server layer, and cloud layer model, enabling the local evaluation model to have inference capabilities consistent with the global model.

[0100] Each organization's client uses its local private test set to perform sample inference on the locally evaluated model. This local private test set is held by each organization's client and contains several sample-label pairs. The samples are the organization's client's private test data, and the labels are the corresponding ground truth labels. The entire inference process is completed locally on the organization's client; the raw data of the local private test set does not leave the organization's client and is not transmitted to the cross-island federation server or other organization's clients. Each organization's client compares the model's predicted output with the corresponding ground truth labels and counts the number of correctly predicted samples, i.e., the number of samples whose predicted output matches the ground truth label. Each organization's client divides the number of correctly predicted samples by the total number of samples in its local private test set to calculate the local accuracy. The local accuracy reflects the performance of the updated global model on the organization's client's private test data.

[0101] In this embodiment, calibration noise is added to the model update to achieve differential privacy protection. For federated learning scenarios, client-level differential privacy is defined to ensure that the impact of data from a single client on the model update is limited. This refers to the federated learning algorithm. and For datasets that differ by only one client, the algorithm satisfies... Differential privacy, if for all output sets : ;in, Indicates privacy budget, This represents the probability of failure. For smaller values... (like This definition provides strong privacy guarantees.

[0102] Differential privacy is achieved by adding Gaussian noise during model aggregation. ;in, This represents the global model after adding noise. The covariance matrix is ​​represented as Gaussian noise, This represents the noise standard deviation. The noise standard deviation is determined based on client-level sensitivity; for gradient aggregation, sensitivity... This represents the maximum contribution of a single client to the gradient. Norm: Gradient clipping ensures bounded sensitivity. ;in, Indicates client gradient, Indicates the clipping threshold. This represents the gradient after clipping. The noise standard deviation is set as follows: For statistics such as confidence thresholds specific to recursive unloading, a similar differential privacy mechanism is employed. Let Indicates client The statistics, with Laplace noise added: ;in, Indicates the sensitivity of the statistic. This represents the Laplace distribution.

[0103] The Rényi Differential Privacy (RDP) accounting method is employed to track the privacy overhead of multi-round training. RDP provides tighter privacy boundaries and supports adaptive privacy budget allocation, satisfying the algorithm's requirements. If for all : ;in, express -Rényi divergence, and This represents the output distribution of the algorithm across neighboring datasets. For Gaussian mechanisms, The parameters are: ;in, RDP represents the standard deviation of Gaussian noise. RDP can be converted to... -DP: ;for Each round of federal training consumes [amount] -RDP privacy budget, the total privacy cost is calculated using the RDP combinatorial theorem: ;in, Indicates the converted -DP privacy budget.

[0104] Each organization's clients can use local, private test suites to verify global model performance without sharing test data, protecting test data privacy while providing accurate model performance evaluation. Indicates organization The local test set contains sample-label pairs. The organization evaluates the global model locally. : ;in, Indicates organization Local accuracy, Indicates an indicator function.

[0105] To provide performance guarantees to other organizations and servers without disclosing specific test samples, privacy-preserving aggregate statistics are used, with each organization reporting accuracy and its confidence interval: ;in, and The lower and upper bounds of the confidence interval are represented by the normal approximation: ;in, Represents the standard normal distribution Quantiles Indicates the significance level. The server aggregates reports from various organizations and calculates a global performance estimate: The estimator is unbiased, and its variance decreases as the number of participating organizations increases.

[0106] In this embodiment, for scenarios with higher privacy requirements, hardware-level protection based on a Trusted Execution Environment (TEE) is provided. The TEE provides an isolated execution environment, ensuring that code and data are not accessed by the operating system or other malware during runtime. In federated learning, the TEE can be used to protect the model aggregation process, preventing individual clients from accessing model updates even if the server is compromised. The aggregation process in the TEE is as follows: the client sends encrypted model updates to the server; the server decrypts and aggregates the data in the TEE, then encrypts the aggregation result and sends it back to the client. Due to the isolation characteristics of the TEE, the server can only see encrypted data and cannot spy on plaintext updates.

[0107] In one embodiment, a cross-data silo federation recursive offloading method for edge computing may further include a process of reporting privacy-preserving summary statistics and calculating global performance metrics. Specifically, each organization's client calculates the lower and upper limits of the confidence interval for its local accuracy based on the amount of data in its local test set, its local accuracy, and a preset significance level. The local accuracy, the upper and lower limits of the confidence interval are then encapsulated into privacy-preserving summary statistics and reported to the cross-data silo federation server. The cross-data silo federation server calculates a weighted global performance metric based on the summary statistics and the amount of local test set data from each organization's client. The cross-data silo federation server determines whether the convergence condition is met based on the weighted global performance metric and the performance records of historical rounds. If the convergence condition is not met, the updated global model parameters are used as the starting point for the next round of training, and the next round of federated learning training is initiated. If the convergence condition is met, a training completion notification is sent to all participating organization clients, and a privacy consumption report is output.

[0108] Each organization's client calculates the standard error based on the local accuracy and the sample size of the local test set. It then looks up the corresponding quantile in the standard normal distribution table according to the preset significance level. Subtracting the quantile from the local accuracy and multiplying it by the standard error yields the lower bound of the confidence interval. Adding the quantile to the local accuracy and multiplying it by the standard error yields the upper bound of the confidence interval. The summary statistics only include the local accuracy value and the upper and lower bounds of the confidence interval; they do not include any original samples, predicted labels, or intermediate features from the local private test set, thus ensuring the privacy of the test data.

[0109] The cross-island federated server uses the proportion of each organization's local test set data to the total local test set data of all participating organizations as weights to calculate a weighted global average accuracy, which serves as the weighted global performance metric. This weighted global performance metric is an unbiased estimator whose expected value equals the true weighted average accuracy of the global model across all organization client test data. Its variance decreases as the number of participating organization clients increases; the more participating organizations, the more stable the estimate of the global performance metric.

[0110] In this embodiment, the convergence condition employs a multi-dimensional joint judgment: First, accuracy change judgment: the cross-island federated server compares the current round's weighted global performance index with the performance record of the most recent round in historical rounds. If the absolute value of the difference between the two is less than a preset accuracy convergence threshold, then the accuracy dimension is determined to converge. Second, target accuracy judgment: if the weighted global performance index reaches a preset target accuracy, then the target dimension is determined to converge. Third, maximum training rounds judgment: if the current training rounds reach a preset maximum number of rounds, then convergence is forcibly determined. Meeting any one of the above three conditions constitutes a convergence condition.

[0111] If the convergence condition is not met, the cross-island federation server distributes the updated global model parameters to each participating organization's client via the global model distributor, and returns to the local training step. Each organization's client then performs local training on its local private dataset based on the new round of global model parameters. If the convergence condition is met, the cross-island federation server sends a training completion notification to all participating organization's clients and outputs a privacy consumption report. The training completion notification includes the final global model parameters and the final weighted global performance metric.

[0112] In one embodiment, for recursive confidence unloading, a fixed threshold can be used instead of an adaptive threshold, using a preset static threshold. This approach eliminates the need to maintain confidence history, resulting in lower computational overhead and suitability for scenarios with stable data distribution or limited computational resources. Fixed thresholds can be determined through cross-validation or set based on expert knowledge. For cross-island federated aggregations, homomorphic encryption can replace secret sharing; homomorphic encryption allows direct computation on encrypted data without an interactive protocol. Specifically, the client uses the Paillier encryption system to update the encryption model. The server calculates a weighted sum on the ciphertext: Then, the aggregated result is obtained by decryption. For privacy protection mechanisms, local differential privacy can be used instead of centralized differential privacy. Each client adds noise locally before uploading, and the server directly aggregates the noisy data without adding additional noise. For model architecture, knowledge distillation can be used instead of end-to-end training. Each organization trains a large private model, and then transfers the knowledge to a shared small model through distillation. Specifically, organizations... Training Teacher Model Then train the student model in federated learning. Minimize distillation losses: Protect the private model architecture while enabling knowledge sharing.

[0113] In one embodiment, an experimental comparison is conducted on a recursive offloading method for cross-data silo federation in edge computing provided in this application. The comparison results are shown in Table 1.

[0114] Table 1 Comparison of model performance under different numbers of participating organizations

[0115]

[0116] As shown in Table 1, the FedSilo method presented in this application outperforms traditional federated learning methods across different numbers of participating organizations. When the number of participating organizations is 10, FedSilo achieves an accuracy of 94.8%, representing a 3.6% improvement over isolated training, and improvements of 1.3% and 1.0% over FedAvg and FedProx, respectively. The performance advantage of FedSilo becomes more pronounced as the number of participating organizations increases.

[0117] The configuration data for each parameter in this application are shown in Table 2:

[0118] Table 2. Main parameter configurations for this embodiment.

[0119]

[0120] As shown in Table 2, this embodiment uses 10 participating organizations, each with 50,000 samples. By reasonably setting parameters such as learning rate, regularization coefficient, and privacy budget, effective privacy protection is achieved while ensuring model performance.

[0121] In this application, a cross-data silo federated learning mechanism is used to enable multiple organizations to collaboratively train a recursive unloading model without sharing the original data. As shown in Table 1, in a scenario with 10 participating organizations, the FedSilo method of this invention achieves an accuracy of 94.8%, which is 3.6% higher than the 91.2% accuracy of isolated training. This performance improvement stems from the comprehensive utilization of cross-organizational data, enabling the model to learn more generalized confidence threshold strategies. Secure multi-party computation (MPC) technology is employed to achieve secure aggregation of model parameters. Each organization calculates global aggregation statistics through a secret sharing protocol, ensuring that no participant can access the original model parameters of other organizations. This maintains acceptable communication and computational overhead while ensuring security, demonstrating the effectiveness of the protocol optimization. The Rényi Differential Privacy (RDP) accounting method is introduced, allocating an independent privacy budget to each organization and tracking privacy overhead across multiple training rounds, maintaining good model performance while meeting formal privacy requirements. Intelligent hierarchical selection is achieved through dynamic confidence threshold learning, allowing most tasks to be processed at lower levels, reducing the frequency of offloading to higher levels. This effect comes from an adaptive threshold learning mechanism, enabling the model to dynamically select the optimal computational level based on task complexity. Allocating an independent privacy budget to each data silo allows different organizations to set different privacy parameters according to their own privacy sensitivity and compliance requirements, avoiding the drawbacks of a uniform privacy protection strategy. This prevents performance degradation caused by over-protection and avoids... It avoids the problem of insufficient protection failing to meet compliance requirements; it designs a local evaluation mechanism, allowing organizations to use local private test sets to verify the performance of the global model without sharing test data. Through privacy-preserving aggregated statistics, organizations can share evaluation results without disclosing specific test samples, solving the problem of test data leakage in traditional federated learning evaluation and enhancing organizations' trust in collaborative training; it also provides a hardware-level privacy enhancement option based on a Trusted Execution Environment (TEE). The TEE provides an isolated execution environment, ensuring that code and data are not accessed by the operating system or other malware during runtime. For scenarios with higher privacy requirements, such as finance and healthcare, organizations can choose to enable TEE protection to provide additional security during model aggregation; the cross-island federated aggregation module can flexibly adapt to different numbers of participating organizations. As shown in Table 1, when the number of participating organizations increases from 5 to 20, the accuracy of this FedSilo method steadily increases from 94.2% to 95.3%, consistently maintaining performance superior to traditional federated learning methods. It can adapt to various application scenarios from small business alliances to large-scale industry collaborations and has good scalability.

[0122] It should be understood that although the steps in the flowchart above are shown sequentially as indicated by the arrows, these steps are not necessarily executed in the order indicated by the arrows. Unless explicitly stated herein, there is no strict order restriction on the execution of these steps, and they can be executed in other orders. Moreover, at least some steps in the flowchart above may include multiple sub-steps or multiple stages. These sub-steps or stages are not necessarily completed at the same time, but can be executed at different times. The execution order of these sub-steps or stages is not necessarily sequential, but can be performed alternately or in turn with other steps or at least some of the sub-steps or stages of other steps.

[0123] In one embodiment, such as Figure 3 As shown, a cross-data silo federation recursive offloading system for edge computing is provided, including: a cross-data silo federation server 110, client units 120 for each organization, a secure multi-party computation aggregator 330, and a differential privacy noise injection and local evaluation module 340, wherein:

[0124] A cross-island federation server 110 is used to distribute the current global model parameters to selected organization clients 120. Each organization client 120 performs local training based on its local dataset and updates its local model parameters.

[0125] Each organization's client 120 is used to calculate the dynamic offloading threshold for the current round based on the local historical confidence queue. When the predicted confidence of the end device is lower than the dynamic threshold of the end device layer, the task is offloaded to the edge server; when the predicted confidence of the edge server layer is lower than the dynamic threshold of the edge server layer, the task is offloaded to the cloud.

[0126] The secure multi-party computation aggregator 330 performs gradient pruning on the local model update through each organization client 120, and then encrypts and divides the pruned model update through the secure multi-party computation protocol to generate each share and distribute it to different server aggregators. The server aggregator performs weighted aggregation on the shares of each organization client 120 locally and restores the global aggregation result through share recombination.

[0127] The differential privacy noise injection and local evaluation module 340 is used to add calibrated Gaussian noise to the global aggregation result to obtain a global model update after differential privacy protection, and to update the global model parameters based on the global model update; each organization's client 120 uses a local private test set to perform local performance evaluation on the updated global model, and reports the privacy-protected summary statistics to the cross-island federation server 110. The cross-island federation server 110 calculates the global performance index based on the summary statistics of each participating organization and determines whether the convergence condition is met. If convergence is not achieved, the next round of training is started.

[0128] In one embodiment, the cross-island federation server 110 is also used to deploy models at the end device layer, edge server layer, and cloud layer respectively, with each model sharing the same input / output interface; establish communication links between the end device layer and the edge server layer, and between the edge server layer and the cloud layer, and configure communication overhead parameters and bandwidth parameters to obtain a three-layer recursive offloading architecture; initialize the three-layer recursive offloading architecture, set dynamic threshold calculation parameters, and initialize global model parameters; at the beginning of each federation round, the cross-island federation server 110 selects clients from participating organizations and distributes the current global model parameters and dynamic threshold calculation parameters to the selected organization clients 120; each organization client 120 uses the received global model parameters as the initial model parameters for local training, performs forward propagation on its local private dataset, calculates the joint loss function, and calculates the gradient through backpropagation; each organization client 120 updates its local model parameters using the gradient.

[0129] In one embodiment, each organization client 120 is further configured to maintain confidence history queues for the end device layer and the edge server layer respectively. After each forward inference, the predicted confidence of the corresponding layer is appended to the end of the corresponding confidence history queue, maintaining a first-in-first-out update to obtain an updated confidence history queue. According to a preset quantile parameter, the confidence value at the corresponding quantile position is selected from the updated confidence history queue as the dynamic unloading threshold for the current round level. When the input sample arrives at the end device, the end device performs inference and outputs the prediction confidence of the end device layer. If the prediction confidence of the end device layer is greater than or equal to the dynamic unloading threshold of the end device layer, the prediction result of the end device layer is used as the final output. If the prediction confidence of the end device layer is lower than the dynamic unloading threshold of the end device layer, the input sample is unloaded from the end device to the edge server.

[0130] In one embodiment, after receiving the unloading sample, the edge server performs inference and outputs the edge server layer prediction confidence. If the edge server layer prediction confidence is greater than or equal to the edge server layer dynamic unloading threshold, the prediction result of the edge server layer is used as the final output. If the edge server layer prediction confidence is lower than the edge server layer dynamic unloading threshold, the unloading sample is unloaded from the edge server to the cloud. The cloud performs inference on the unloading sample and outputs the final prediction result. Each organization client 120 reports the dynamic unloading threshold calculated in this round to the cross-island federated server 110. The cross-island federated server 110 determines the weight based on the local data volume of each organization, calculates the global dynamic threshold through weighted quantiles, and distributes the global dynamic threshold to each participating organization client 120 at the start of the next round of federated learning.

[0131] In one embodiment, each organization client 120 is further configured to calculate the difference between the updated local model parameters and the received global model parameters to obtain the model update increment, and calculate the vector length of the model update increment; compare the vector length with a preset pruning threshold, and if it does not exceed the pruning threshold, keep the model update increment unchanged; if it exceeds the pruning threshold, scale the model update increment proportionally according to the ratio of the pruning threshold to the current vector length, so that the scaled vector length is equal to the pruning threshold; each organization client 120 randomly divides the pruned model update vector into shares, each share is randomly distributed in value, and the element-wise sum of all shares is equal to the original model update vector; each organization client 120 sends each share to each server aggregator.

[0132] In one embodiment, after each server aggregator receives the corresponding share from all organization clients 120, it determines the weighting coefficient based on the proportion of the local data volume of each organization client 120 to the total data volume of all participating organizations. It then performs a weighted summation of all received shares locally according to the weighting coefficient to generate a partial aggregation result for each server aggregator. The cross-island federation server 110 collects the partial aggregation results of all server aggregators and performs element-wise summation. By utilizing the secret shared additive homomorphic property, the random shares introduced by each organization client 120 during the partitioning are completely canceled out during the cross-server summation process, restoring a global aggregation result equal to the weighted summation of the incremental model updates after each organization's pruning.

[0133] In one embodiment, the cross-island federation server 110 is also used to calculate the intensity parameter of Gaussian noise, sample noise vectors from a Gaussian distribution with a mean of zero based on the intensity parameter, add the noise vectors to the global aggregation result to obtain a differential privacy-preserving global model update, and then add the differential privacy-preserving global model update to the current global model parameters element by element to generate updated global model parameters; the updated global model parameters are distributed to each participating organization client 120 through a secure communication channel, each organization client 120 loads the updated global model parameters as a local evaluation model, calls the local private test set to perform sample inference on the local evaluation model, compares the model prediction output with the corresponding real label to count the number of correct predictions, calculates the local accuracy, and completes the local performance evaluation.

[0134] In one embodiment, each organization client 120 is further configured to calculate the lower and upper limits of the confidence interval for the local accuracy based on the amount of local test set data, the local accuracy, and a preset significance level; encapsulate the local accuracy, the upper and lower limits of the confidence interval into privacy-preserving summary statistics; and report these statistics to the cross-island federated server 110. The cross-island federated server 110 calculates a weighted global performance index based on the summary statistics and the amount of local test set data of each organization client 120; based on the weighted global performance index and the performance records of historical rounds, it determines whether the convergence condition is met. If the convergence condition is not met, the updated global model parameters are used as the starting point for the next round of training, and the next round of federated learning training is started. If the convergence condition is met, a training completion notification is sent to all participating organization clients 120, and a privacy consumption report is output.

[0135] In one embodiment, an application architecture for a cross-data silo federation recursive offloading method and system oriented towards edge computing is provided, as follows: Figure 4 As shown, the overall architecture adopts a server-client architecture, including key components such as a cross-island federated server, multiple organization-specific private datasets, a three-layer recursive offloading model, a secure multi-party computation aggregator, a differential privacy noise injector, a trusted execution environment, a local evaluation module, a global model distributor, and a confidence history manager. The cross-island federated server coordinates the federated learning training process, distributing the global model parameters for the current round to participating organizations through the global model distributor. Each organization performs training on its local private dataset, while simultaneously utilizing the three-layer recursive offloading architecture for intelligent inference: the edge device model first performs predictions; when the confidence level falls below a dynamic threshold, the task is offloaded to the edge server model; if the confidence level at the edge layer is still insufficient, it is further offloaded to the large model in the cloud. The confidence history manager collects historical confidence data from each layer and calculates adaptive dynamic thresholds. This implements a percentile-based threshold update strategy. After training, each organization cryptographically aggregates its model updates via a secure multi-party computation aggregator, employing a secret-sharing protocol to ensure that individual organization's model parameters are not leaked. A trusted execution environment provides optional hardware-level privacy enhancements suitable for highly sensitive scenarios. A differential privacy noise injector adds calibrated Gaussian noise to the aggregation results. ,satisfy - Differential privacy requirements. The local evaluation module allows organizations to validate the global model performance using private test sets, sharing only summary statistics without leaking test data. The updated global model is returned to the cross-island federated servers via the global model distributor for the next round of training. This overall architecture, through hierarchical privacy protection mechanisms and recursive offloading optimization, enables organizations to collaboratively train high-performance recursively offloaded models while meeting strict privacy requirements.

[0136] In one embodiment, a cross-data silo federated recursive offloading system for edge computing may further include a secure multi-party computation aggregation module, the structure of which is as follows: Figure 5 As shown, the secure multi-party computation aggregation module employs a secret-sharing-based protocol to securely aggregate model parameters across organizations. This module includes a secret-sharing generator, model updates for each organization, a share partitioning module, a multi-server aggregator, a share recombination module, a weighted aggregation calculator, a noise calibration module, a verification protocol module, and an aggregation result outputter. During the aggregation process, each organization updates its locally trained model vector. Input share splitting module. The secret sharing generator generates random share seeds for each organization, ensuring the randomness and independence of the shares. The share splitting module updates each model. Divided into Individual shares ,satisfy Each share is sent to the corresponding server aggregator, and each server calculates the partial aggregation result locally. ,in These weighting coefficients are determined based on the amount of data from each organization. The share reorganization module collects partial aggregation results from all servers and reconstructs the final secure aggregation result by summing the shares. The weighted aggregation calculator weights the aggregation results based on the amount of organizational data. The noise calibration module adds calibrated Gaussian noise to the aggregation results. The noise standard deviation Gradient clipping threshold Failure probability and privacy budget Joint decision to ensure satisfaction Differential privacy requirements. The verification protocol module uses a commitment mechanism to verify the validity of the shares submitted by each organization, through a hash function. The system verifies noise commitments to prevent malicious organizations from inferring other organizations' model updates through carefully selected shares. If verification fails, the system returns to the share partitioning module to regenerate shares. The aggregation result outputter outputs the final aggregated model update after successful verification, for use in global model updates. This module ensures true privacy-preserving aggregation through dual protection of secret sharing and verification protocols, guaranteeing that no single server or organization can access other organizations' original model parameters during the aggregation process.

[0137] In one embodiment, the interaction timing of the cross-island federated training method is as follows: Figure 6The diagram illustrates the complete training process from server distribution to model convergence. The timeline involves participants such as a cross-island federated server S, multiple organization clients 1 to K, a secure multi-party computation aggregator (SMPC), a differential privacy module (DP), and a trusted execution environment (TEE). At the start of training, server S distributes the global model parameters for the current round to all selected organization clients 1 to K. Each organization's clients have their own local private datasets. Perform local training and calculate gradients. And update the model parameters ,in The learning rate. Meanwhile, each organization uses historical confidence queues. Calculate dynamic threshold This is used for recursive unloading decisions. After local training is complete, each organization uses a private test set. Evaluate global model performance and calculate local accuracy. The confidence interval provides a privacy-preserving evaluation basis for model performance. To ensure compliance with differential privacy sensitivity requirements, organizations prune gradients, limiting the gradient norm to a threshold value. Within: Gradient increment after clipping It was uploaded to the Secure Multi-Party Computation Aggregator (SMPC). SMPC uses a secret-sharing protocol to divide each organization's model updates into... Each share is distributed to different servers, each server independently calculates its partial aggregation, and finally the global aggregation result is recovered through share recombination. For scenarios with higher privacy requirements, SMPC can selectively place the aggregation process within a Trusted Execution Environment (TEE), leveraging hardware isolation to provide stronger security. The aggregation result is then passed to the Differential Privacy Module (DP), which adds calibrated Gaussian noise. The noise standard deviation According to privacy budget Failure probability and clipping threshold Calculation. The noisy global update is returned to server S, and the server updates the global model as follows. At the same time, each organization submits privacy protection assessment statistics to the server, which then calculates global performance metrics. The system then checks the convergence criteria. If the model fails to converge, the server initiates the next round of training; if it has converged, a training completion notification is sent to all organizations. This timeline, through the organic combination of secure multi-party computation and differential privacy, ensures that the model parameters, gradient information, and test data of each organization are strictly protected throughout the entire federated training process, achieving true privacy-preserving cross-organizational collaboration.

[0138] Time series Figure 6The diagram illustrates the core interaction chain during method execution. To avoid excessive original fine-grained messages affecting Mermaid rendering and review, adjacent local operations, repeated calibration actions, and fragmented messages within conditional branches have been merged into a small number of main steps, while maintaining the original sequence of input, decision, upgrade, feedback, and update stages.

[0139] In one embodiment, a federated recursive offloading method and system for edge computing across data silos can be deployed in a cross-organizational edge intelligence service network consisting of 10 enterprises. Each enterprise possesses its own private dataset, including sensitive information such as customer service records, product reviews, and user feedback. Due to data privacy regulations and business competition constraints, enterprises cannot directly share raw data but wish to improve the performance of the recursive offloading model through collaborative training. The main challenge in this scenario is how to achieve cross-organizational statistical information aggregation and dynamic threshold learning while ensuring that the model parameters and gradient information of each enterprise are not leaked. The amount of data from participating enterprises ranges from 10,000 to 50,000 samples, distributed across different business domains, requiring a federated learning mechanism to coordinate the heterogeneous data distribution. The specific process is as follows: Figure 7 As shown:

[0140] M1: Server initialization and shared parameter distribution. The cross-island federation server first constructs a three-tier recursive offloading architecture of end devices, edge servers, and the cloud, and initializes global model parameters. The server is configured with dynamic threshold parameters, including quantile parameters. and the length of the historical queue These parameters control the triggering conditions for cross-level offloading. The server also initializes the secure multi-party computation protocol, assigns encryption keys and share identifiers to participating companies, and prepares to receive encryption model updates.

[0141] M2: Enterprise-level local training and confidence score collection. Each enterprise client receives global model parameters. Then, in the local private dataset Perform local training, calculate gradients, and update the local model. The learning rate During training, the enterprise client collects confidence scores from the terminal device layer and the edge layer. and Maintain the local confidence historical queue and This is used for subsequent dynamic threshold calculation. Based on the parameter configuration in Table 2, the data volume for each enterprise is 50,000 samples, and the training batch size is 32.

[0142] M3: Dynamic threshold calculation and offloading decision. Each enterprise calculates dynamic thresholds based on its local confidence history. The threshold uses the 30th percentile as the unloading trigger point to ensure that only low-confidence difficult cases are unloaded to higher levels. Enterprise clients use dynamic thresholds to perform recursive unloading decisions: if the terminal device's confidence level... If the edge confidence level is low, the task will be offloaded to the edge server; Then, it is further unloaded to the large model in the cloud. This step records the statistics of the unloading path. This includes the number of samples processed at each level.

[0143] M4: Gradient pruning and sensitivity control. To ensure compliance with differential privacy sensitivity requirements, each company performs pruning operations on its local gradients, limiting the gradient norm to a threshold value. Within: Gradient increment after clipping Prepare for uploading as a model update. Based on the configuration in Table 2, set the pruning threshold. This ensures that the impact of individual enterprises on global updates is bounded, providing a sensitive basis for subsequent differential privacy noise injection.

[0144] M5: Share splitting and encrypted upload. Each enterprise uses a secret sharing protocol to update its local model. Divided into Each share, satisfying Each company will [do something - likely related to the company's first business]. Each share is sent to the corresponding server aggregator to ensure that a single server cannot recover the complete model update. This step also generates noisy commitments. ,in This is random noise, used for subsequent integrity checks of the verification protocol.

[0145] M6: Secure multi-party computation aggregation. Each server aggregator receives the share from all enterprises and performs partial aggregation locally. The weighting coefficient The amount of data is determined based on each enterprise's data volume. All servers add up partial aggregation results, and the globally secure aggregation result is recovered through share reorganization. This protocol ensures that no single server or enterprise can access the original model parameters of other enterprises during the aggregation process.

[0146] M7: Differential Privacy Noise Injection. The secure aggregator passes the aggregation result to the differential privacy noise injector, which adds calibrated Gaussian noise. The noise standard deviation Based on the privacy budget in Table 2 and failure probability The noise standard deviation is calculated and injected into the aggregation result. Global update after adding noise. satisfy Differential privacy requirements provide enterprises with formalized privacy protection.

[0147] M8: Local evaluation and performance verification. Each enterprise uses its own proprietary test suite. Evaluate the performance of the updated global model locally and calculate the local accuracy. and confidence interval Enterprises only submit summary statistics to the server. The specific test samples will not be disclosed. The server calculates global performance metrics. It is used to monitor the convergence of the model.

[0148] M9: Global Model Update and Result Writeback. The server updates the global model parameters using the noisy global update. The updated parameters are distributed to participating companies via a global model distributor. The server simultaneously checks the model convergence condition; if convergence fails, the next round of training begins; if convergence is achieved, a training completion notification is sent to all companies. Based on the data in Table 1, the FedSilo method achieved an accuracy of 94.8% with 10 participating organizations, a 3.6% improvement over the 91.2% achieved through isolated training, validating the effectiveness of cross-organizational collaboration.

[0149] This embodiment achieved a model accuracy of 94.8% in a scenario involving 10 enterprises, a significant improvement over the 91.2% achieved through isolated training. Secure multi-party computation aggregation introduces only limited additional communication and computational overhead, demonstrating the effectiveness of the protocol optimization. The differential privacy mechanism contributes to privacy budgeting. It can still maintain a high accuracy rate and provide verifiable privacy protection; cross-organizational collaboration enables enterprises to fully leverage the advantages of heterogeneous data while meeting strict privacy requirements, learn confidence threshold strategies with stronger generalization ability, and significantly improve the practical value of recursive unloading models in real business scenarios.

[0150] In one embodiment, a federated recursive offloading method and system for edge computing across data silos can be deployed in a cross-regional medical data collaboration network composed of multiple medical institutions. Each hospital possesses independent medical text data, including highly sensitive information such as electronic medical record summaries, patient feedback, and clinical notes. Due to medical privacy regulations and patient confidentiality requirements, hospitals cannot share raw medical data but wish to improve model performance for recursive offloading tasks such as sentiment analysis and symptom recognition through collaborative training. The main challenges in this scenario are significant differences in data distribution among hospitals, cold start problems in some hospitals, and limited annotation resources, requiring a federated learning mechanism to provide personalized protection and domain adaptability. The specific process is as follows: Figure 8 As shown:

[0151] M1: Server initialization and shared parameter distribution. A three-tier recursive offloading architecture for medical text is constructed across isolated federated servers to initialize global model parameters. The server has a stricter privacy budget set for medical scenarios. This ensures strong privacy protection in highly sensitive medical environments. The server simultaneously initializes a Trusted Execution Environment (TEE) module, providing an optional isolated execution environment for hospitals requiring hardware-level privacy protection. The TEE employs hardware isolation features to ensure that even if the server is compromised during model aggregation, it cannot obtain model updates from individual hospitals.

[0152] M2: Local training and domain adaptation within hospitals. Each hospital client receives global model parameters. Then, in the local medical dataset Perform local training, calculate gradients, and update the local model. To address the domain-specific differences in medical text, the hospital client employs a domain-adaptive loss function, combining prediction accuracy loss and a domain regularization term: ,in This is the domain regularization coefficient, which helps the model adapt to the medical text styles of different hospitals.

[0153] M3: Dynamic Threshold Calculation and Offloading Decision. Each hospital calculates the dynamic threshold based on the confidence distribution of local medical data. The threshold adopts a more conservative approach. Quantiles are used to meet the higher accuracy requirements of medical scenarios. The hospital client uses dynamic thresholds to perform recursive offloading decisions: if the terminal device's confidence level... If the edge confidence level is low, the task will be offloaded to the edge server; Then, it is further unloaded to a large cloud model. This step records the unique unloading path statistics of medical texts, distinguishing the processing hierarchy distribution of diagnostic and consultation texts.

[0154] M4: Gradient clipping and orthogonal regularization. To ensure medical data privacy, hospitals perform local gradient clipping operations, limiting the gradient norm to a threshold value. Within: Gradient increment after clipping Orthogonal regularization was applied to prevent the model from overfitting to the data distribution of a single hospital. ,in These are the orthogonal regularization coefficients. This represents the orthogonal complement space projected onto the global model parameters.

[0155] M5: Share partitioning and TEE-protected upload. Hospitals use a secret sharing protocol to update their local models. Divided into Each share, satisfying For hospitals that have enabled TEE protection, shares are encrypted before entering the TEE, decrypted internally within the TEE, and then aggregated to ensure that even server administrators cannot see the plaintext shares. This step also generates noisy commitments. The company commits to completing verification within the TEE to prevent malicious hospitals from inferring the characteristics of other hospitals' medical data through carefully selected shares.

[0156] M6: Secure multi-party computation aggregation with TEE isolation. Each server aggregator receives shares from all hospitals within a TEE-isolated environment and computes the partial aggregation results locally. The weighting coefficient The specific data volume is determined based on the hospitals' data volumes. The hardware isolation feature of the TEE ensures complete isolation during the aggregation process; even the operating system or malware cannot access the plaintext data within the TEE. All servers add up partial aggregation results and recover the globally secure aggregation result through share reassembly. .

[0157] M7: Differential Privacy Noise Injection and Cold Start Protection. The secure aggregator passes the aggregation results to the differential privacy noise injector. This module adds calibrated Gaussian noise specifically for medical scenarios. The noise standard deviation Based on a stricter privacy budget A larger noise standard deviation is calculated to provide strong privacy protection. For cold-start hospitals with limited data, an adaptive noise scaling mechanism is used to reduce the impact of noise. ,in This is the cold start threshold.

[0158] M8: Local assessment and personalized validation. Hospitals use proprietary medical test suites. Evaluate the performance of the updated global model locally and calculate the local accuracy. And medical-specific indicators such as recall rate The hospital only submits summary statistics to the server. Specific medical cases will not be disclosed. The server calculates global performance metrics. At the same time, it monitors the differences in personalized performance among hospitals to provide a basis for subsequent personalized adjustments.

[0159] M9: Global Model Update and Personalization Adjustment. The server updates the global model parameters using a noisy global update. The updated parameters are then distributed to participating hospitals via a global model distributor. To address performance differences among hospitals, the server employs a personalized adjustment mechanism to generate customized adaptation parameters for hospitals with significantly lower-than-average accuracy. ,in For personalization coefficient, These are the globally averaged model parameters. The server checks the model convergence condition; if it has not converged, it starts the next round of training; if it has converged, it sends a training completion notification to all hospitals.

[0160] This embodiment is based on a strict privacy budget. High model accuracy was achieved even in medical scenarios; the TEE isolation environment provided hardware-level privacy protection for medical data. Although it increased computational overhead, it ensured that even if the server was compromised, model updates for individual hospitals could not be obtained; the personalized adjustment mechanism further improved the accuracy of cold-start hospitals with smaller datasets, narrowing the performance gap with large hospitals; orthogonal regularization effectively prevented the model from overfitting to the medical text style of a single hospital, enabling the global model to achieve better generalization ability while maintaining hospital personalization; cross-organizational collaboration enabled hospitals to fully utilize multi-source medical data while complying with medical privacy regulations, significantly improving the practical value of recursive offloading tasks such as sentiment analysis and symptom recognition in real medical scenarios.

[0161] In one embodiment, a computer device is provided, including a memory and a processor, the memory storing a computer program, the processor executing the computer program to implement steps of a recursive offloading method for cross-data silo federation oriented to edge computing.

[0162] In one embodiment, a computer-readable storage medium is provided having a computer program stored thereon, the computer program being executed by a processor to implement the steps of a recursive offloading method for cross-data silo federation for edge computing.

[0163] Those skilled in the art will understand that all or part of the processes in the methods of the above embodiments can be implemented by a computer program instructing related hardware. The computer program can be stored in a non-volatile computer-readable storage medium, and when executed, it can include the processes of the embodiments of the above methods. Any references to memory, storage, databases, or other media used in the embodiments provided in this application can include non-volatile and / or volatile memory. Non-volatile memory can include read-only memory (ROM), programmable ROM (PROM), electrically programmable ROM (EPROM), electrically erasable programmable ROM (EEPROM), or flash memory. Volatile memory can include random access memory (RAM) or external cache memory. By way of illustration and not limitation, RAM is available in various forms, such as static RAM (SRAM), dynamic RAM (DRAM), synchronous DRAM (SDRAM), dual data rate SDRAM (DDRSDRAM), enhanced SDRAM (ESDRAM), synchronous link DRAM (SLDRAM), Rambus direct RAM (RDRAM), direct memory bus dynamic RAM (DRDRAM), and memory bus dynamic RAM (RDRAM), etc.

[0164] The technical features of the above embodiments can be combined in any way. For the sake of brevity, not all possible combinations of the technical features in the above embodiments are described. However, as long as there is no contradiction in the combination of these technical features, they should be considered to be within the scope of this specification.

[0165] The embodiments described above are merely illustrative of several implementation methods of this application, and while the descriptions are specific and detailed, they should not be construed as limiting the scope of the invention. It should be noted that those skilled in the art can make various modifications and improvements without departing from the concept of this application, and these all fall within the protection scope of this application. Therefore, the protection scope of this application should be determined by the appended claims.

Claims

1. A recursive offloading method for cross-data silo federation in edge computing, characterized in that, The method includes: A three-layer recursive offloading architecture is constructed, consisting of end devices, edge servers, and the cloud. In each round of federated learning training, the cross-island federated servers distribute the current global model parameters to the selected organization clients. Each organization client performs local training based on its local dataset and updates its local model parameters. Each organization's client calculates the dynamic offload threshold for the current round based on its local historical confidence queue. When the predicted confidence of the end device is lower than the dynamic threshold at the end device layer, the task is offloaded to the edge server. When the predicted confidence at the edge server layer is lower than the dynamic threshold at the edge server layer, the task is offloaded to the cloud. Each of the organization clients performs gradient pruning on the local model update, and then encrypts and divides the pruned model update through a secure multi-party computation protocol to generate shares, which are then distributed to different server aggregators. The server aggregator performs weighted aggregation on the shares of each organization client locally, and restores the global aggregation result through share recombination. A calibrated Gaussian noise is added to the global aggregation result to obtain a differentially privacy-preserving global model update. The global model parameters are then updated based on this global model update. Each organization's client uses its local private test set to perform a local performance evaluation of the updated global model and reports privacy-preserving aggregated statistics to the cross-island federation server. The cross-island federation server calculates the global performance index based on the aggregated statistics of each participating organization and determines whether the convergence condition is met. If convergence is not achieved, the next round of training is initiated.

2. The cross-data silo federation recursive offloading method for edge computing as described in claim 1, characterized in that, A three-tier recursive offloading architecture is constructed, consisting of end devices, edge servers, and the cloud. In each round of federated learning training, the cross-island federated servers distribute the current global model parameters to selected organization clients. Each organization client performs local training based on its local dataset and updates its local model parameters, including: The cross-island federation server deploys models at the end device layer, edge server layer, and cloud layer, with each model sharing the same input / output interface; communication links are established between the end device layer and the edge server layer, and between the edge server layer and the cloud layer, and communication overhead parameters and bandwidth parameters are configured to obtain a three-layer recursive offloading architecture; The cross-island federation server initializes the three-tier recursive offloading architecture, sets dynamic threshold calculation parameters, and initializes global model parameters. At the start of each federation round, the cross-island federation server selects clients from participating organizations and distributes the current global model parameters and the dynamic threshold calculation parameters to the selected organization clients. Each of the organization's clients uses the received global model parameters as the initial model parameters for local training, performs forward propagation on its local private dataset, calculates the joint loss function, and calculates the gradient through backpropagation; each of the organization's clients uses the gradient to update its local model parameters.

3. The cross-data silo federation recursive offloading method for edge computing as described in claim 1, characterized in that, Each of the organization's clients calculates the dynamic offloading threshold for the current round based on its local historical confidence queue. When the predicted confidence of the end device is lower than the dynamic threshold at the end device layer, the task is offloaded to the edge server. When the prediction confidence level of the edge server layer falls below the dynamic threshold of the edge server layer, the task is offloaded to the cloud, including: Each of the organization's clients maintains a confidence history queue at the terminal device layer and the edge server layer, respectively. After each forward inference, the predicted confidence output by the corresponding layer is appended to the end of the corresponding confidence history queue, maintaining a first-in-first-out update to obtain the updated confidence history queue. Each of the organization's clients selects the confidence value at the corresponding quantile position from the updated confidence history queue as the dynamic unloading threshold for the current round level, according to the preset quantile parameters. When an input sample arrives at the end device, the end device performs inference and outputs the end device layer prediction confidence. If the end device layer prediction confidence is greater than or equal to the end device layer dynamic offloading threshold, the prediction result of the end device layer is used as the final output. If the end device layer prediction confidence is lower than the end device layer dynamic offloading threshold, the input sample is offloaded from the end device to the edge server.

4. The cross-data silo federation recursive offloading method for edge computing according to claim 3, characterized in that, When the prediction confidence level of the edge server layer falls below the dynamic threshold of the edge server layer, the task is offloaded to the cloud, including: After receiving the unloading sample, the edge server performs inference and outputs the edge server layer prediction confidence. If the edge server layer prediction confidence is greater than or equal to the edge server layer dynamic unloading threshold, the prediction result of the edge server layer is used as the final output; if the edge server layer prediction confidence is lower than the edge server layer dynamic unloading threshold, the unloading sample is unloaded from the edge server to the cloud. The cloud platform performs inference on the unloading samples and outputs the final prediction result. Each organization's client reports the dynamic offload threshold calculated in this round to the cross-island federation server. The cross-island federation server determines the weight based on the amount of local data of each organization, calculates the global dynamic threshold through weighted quantiles, and distributes the global dynamic threshold to each participating organization's client at the start of the next round of federated learning.

5. The cross-data silo federation recursive offloading method for edge computing according to claim 1, characterized in that, Each of the aforementioned organizational clients performs gradient pruning on local model updates, and then cryptographically divides the pruned model updates using a secure multi-party computation protocol to generate individual shares, which are then distributed to different server aggregators, including: Each organization's client calculates the difference between the updated local model parameters and the received global model parameters to obtain the model update increment, and calculates the vector length of the model update increment; The vector length is compared with a preset pruning threshold. If it does not exceed the pruning threshold, the model update increment remains unchanged. If it exceeds the pruning threshold, the model update increment is scaled proportionally according to the ratio of the pruning threshold to the current vector length, so that the scaled vector length is equal to the pruning threshold. Each organization client randomly divides the trimmed model update vector into shares, each share being randomly distributed in value, and the element-wise sum of all shares equals the original model update vector. Each organization client then sends each share to its respective server aggregator.

6. The recursive offloading method for cross-data silo federation oriented to edge computing according to claim 5, characterized in that, The server aggregator performs weighted aggregation of the shares of each organization's clients locally, and restores the global aggregation result through share reorganization, including: After receiving the corresponding share from all organization clients, each of the server aggregators determines a weighting coefficient based on the proportion of the local data volume of each organization client to the total data volume of all participating organizations. Locally, all received shares are weighted and summed according to the weighting coefficient to generate a partial aggregation result for each of the server aggregators. The cross-island federation server collects the partial aggregation results from all server aggregators and performs element-wise summation. By utilizing the secret-shared additive homomorphic property, the random share introduced by each organization's client during the splitting process is completely canceled out during the cross-server summation process, restoring a global aggregation result equal to the weighted sum of the incremental model updates after each organization's pruning.

7. The cross-data silo federation recursive offloading method for edge computing according to claim 1, characterized in that, A calibrated Gaussian noise is added to the global aggregation result to obtain a differential privacy-preserving global model update, and the global model parameters are updated based on the global model update. Each organization's client uses a local private test suite to perform local performance evaluations of the updated global model, including: The cross-island federation server calculates the intensity parameter of Gaussian noise, samples a noise vector from a Gaussian distribution with a mean of zero based on the intensity parameter, adds the noise vector to the global aggregation result to obtain a differential privacy-preserving global model update, and then adds the differential privacy-preserving global model update to the current global model parameters element by element to generate the updated global model parameters. The cross-island federation server distributes the updated global model parameters to each participating organization's client through a secure communication channel. Each organization's client loads the updated global model parameters into a local evaluation model, calls a local private test set to perform sample inference on the local evaluation model, compares the model's prediction output with the corresponding real labels to count the number of correct predictions, calculates the local accuracy, and completes the local performance evaluation.

8. The recursive offloading method for cross-data silo federation oriented to edge computing according to claim 7, characterized in that, The cross-island federation server reports aggregated statistics on privacy protection. Based on these aggregated statistics from each participating organization, the cross-island federation server calculates global performance metrics and determines whether convergence is met. If convergence fails, the next round of training is initiated, including: Each of the organization's clients calculates the lower and upper limits of the confidence interval for the local accuracy based on the amount of data in the local test set, the local accuracy, and the preset significance level. The local accuracy, the upper and lower limits of the confidence interval are then encapsulated into privacy-preserving summary statistics and reported to the cross-island federation server. The cross-island federation server calculates a weighted global performance index based on the aggregated statistics and the amount of local test set data from each organization's clients. The cross-island federated server determines whether the convergence condition is met based on the weighted global performance metric and the performance records of the historical rounds. If the convergence condition is not met, the updated global model parameters are used as the starting point for the next round of training to start the next round of federated learning training. If the convergence condition is met, a training completion notification is sent to all participating organization clients, and a privacy consumption report is output.

9. A recursive offloading system for cross-data silos federated by edge computing, characterized in that, The system includes: A cross-island federation server is used to distribute the current global model parameters to selected organization clients, each of which performs local training based on its local dataset and updates its local model parameters. Each of the organization's clients is used to calculate the dynamic offloading threshold for the current round based on the local historical confidence queue. When the predicted confidence of the terminal device is lower than the dynamic threshold of the terminal device layer, the task is offloaded to the edge server; when the predicted confidence of the edge server layer is lower than the dynamic threshold of the edge server layer, the task is offloaded to the cloud. The secure multi-party computation aggregator performs gradient pruning on the local model update through the clients of each organization, and then encrypts and divides the pruned model update through a secure multi-party computation protocol to generate shares and distribute them to different server aggregators. The server aggregator performs weighted aggregation on the shares of each client of each organization locally and restores the global aggregation result through share recombination. The differential privacy noise injection and local evaluation module is used to add calibrated Gaussian noise to the global aggregation result to obtain a differential privacy-protected global model update, and to update the global model parameters based on the global model update. Each organization's client uses a local private test set to perform local performance evaluation on the updated global model, and reports the privacy-protected summary statistics to the cross-island federation server. The cross-island federation server calculates the global performance index based on the summary statistics of each participating organization and determines whether the convergence condition is met. If convergence is not achieved, the next round of training is started.

Images