Semantic feedback guided structure adaptive federated learning method and system, and medium

Abstract

The invention discloses a semantic feedback guided structure adaptive federated learning method and system and a medium, and belongs to the technical field of federated learning and deep neural network training, and the system comprises a FedBR basic framework, a multi-source feedback statistics module, a block scheduling strategy module and a coverage fair constraint module. According to the method, a probabilistic deep block scheduling strategy is introduced, so that the system can gradually deviate to block combinations with better effects according to accumulated feedback, and a certain degree of online self-adaptive capability is shown in an experimental scene. A time window and exponential moving average non-stationary feedback smoothing mechanism is adopted, the influence of single-round noise and partial observation on strategy updating is reduced, the strategy updating is more stable, and the frequency of strategy oscillation and extreme bias conditions is reduced. And when the probability distribution P is updated, probability distribution smoothness and coverage fairness constraints are introduced, so that extreme conditions that the deep block is not selected for a long time are obviously reduced, and the overall training participation degree of the deep block is improved.

Description

Technical Field

[0001] This invention relates to the fields of federated learning and deep neural network training technology, specifically to a semantic feedback-guided structure-adaptive federated learning method, system, and medium. Background Technology

[0002] Traditional federated learning methods, such as FedAvg, distribute the complete global model to participating clients in each training round, and then aggregate and update the complete parameters trained locally on the clients. This type of method performs well in scenarios where the data is relatively independent and homogeneous, and the differences in device capabilities are not significant. However, in real-world systems where there are large differences in terminal computing power and bandwidth, synchronizing the complete model can lead to a significant communication burden, and weaker devices are also difficult to participate stably for extended periods.

[0003] To alleviate the aforementioned problems, a class of layer-wise or block-wise federated learning methods has emerged in recent years. These methods reduce communication overhead by training and backpropagating only a subset of the model's layers or blocks, and allow less capable clients to participate in training on a smaller subset of the model. Existing work typically employs static or heuristic deterministic strategies to select these partial parameters.

[0004] FedBR proposed a representative block-wise federated training framework. Its main ideas include:

[0005] a. Divide the deep network into multiple consecutive blocks in forward order.

[0006] b. The server determines the number of blocks k for this round of training for the client based on the client's computing power and communication capabilities.

[0007] c. After determining k, send k consecutive deep blocks to the client, forming a continuous tail segment using a fixed sending method.

[0008] d. The client only receives the last alpha consecutive global blocks and combines them with the remaining blocks retained locally to form a complete local model. After completing the training locally, the client sends back the complete local model, and the server performs an aggregation update on the complete model.

[0009] e. Block-wise regularization and block-wise knowledge distillation are introduced into the client training objective to reduce the local learning bias caused by non-independent and identically distributed data.

[0010] f. Perform a full round of training every certain number of rounds, distributing all blocks for full model training to recalibrate global alignment and reward scale.

[0011] FedBR has achieved good results in communication compression and heterogeneous adaptation, and is an important baseline for block-wise federated learning. However, it still has several problems in scenarios with strong non-independent and identically distributed architectures and significant differences in terminal capabilities:

[0012] 1. In FedBR, after FedBR gives the client a budget of the number of blocks k, the server determines the deep block segments by "fixed distribution of k consecutive blocks at the end". It is difficult to dynamically adjust according to the changes in the contribution of each block during the training phase, and the distribution rules are relatively rigid.

[0013] 2. When only a portion of the blocks participate in the backhaul, the server's observation of the block's effect is limited, and directly updating the strategy based on a single round of revenue is prone to bias and oscillation.

[0014] 3. Due to feedback bias and strong dominance, some deep blocks may have a very low probability of being selected for a long time, or they may be simply regarded as "poor blocks" and continuously weakened, resulting in the phenomenon of block "starvation".

[0015] Therefore, while keeping the FedBR main pipeline unchanged, it is necessary to upgrade the policy layer of the block scheduling and feedback update submodule to enable scheduling to have a certain degree of adaptability, make feedback smoother and more stable, and provide opportunities to re-explore underestimated blocks during long-term training.

[0016] Based on this, the present invention designs a semantic feedback-guided structure-adaptive federated learning method, system, and medium to solve the above problems. Summary of the Invention

[0017] To address the aforementioned shortcomings of existing technologies, this invention provides a semantic feedback-guided structure-adaptive federated learning method, system, and medium. While maintaining the basic block-wise pipeline of FedBR, this invention upgrades the policy layer of its block scheduling and feedback update submodules. By constructing block-level semantic feedback that integrates real and proxy rewards between the client and server, a closed-loop mechanism is formed that balances exploration, utilization, stability, and coverage, making the structure-adaptive process explicitly dependent on these semantic feedback signals.

[0018] To achieve the above objectives, the present invention provides the following technical solution:

[0019] A semantic feedback-guided structure-adaptive federated learning method, with the following specific steps:

[0020] Step 1: Model segmentation;

[0021] Step 2: Assess client capabilities and determine candidate block count ranges;

[0022] Step 3: Decision on the block number budget alpha(u,t);

[0023] Step 4: Determine the full model training round and generate the block set: Let full(t) represent whether the t-th round is the full model training round. When full(t)=1, the server sends all B blocks to the client; when full(t)=0, the server first sends the necessary shallow blocks and selects the rest from the deep block set S_deep.

[0024] Step 5: Probabilistic deep block selection and distribution

[0025] When full(t) = 0, the server selects K_deep(u,t) blocks from the deep block set S_deep and sends them to the client u. The server maintains four types of state variables for each deep block_b: the mean or smoothed return estimate of the block's advantage, mu(b), the uncertainty variance of the block, sigma2(b), the weight of the fairness constraint, lambda(b), and the number of rounds the block has experienced since its last selection, gap(b). The server also sets the lower limit of variance, sigmafloor2, the time window W, the stale compensation coefficient, stale_gamma, and the upper limit of compensation, stale_cap. In each round, the server first samples the perturbation xi(b) from a Gaussian distribution with a mean of 0 and a variance not less than sigmafloor2 to construct a random advantage sample.

[0026] theta(b)=mu(b)+xi(b)+stale_gamma min(gap(b) / W,stale_cap)

[0027] The sorting priority score is obtained by overlaying the covering constraint terms:

[0028] s(b) = theta(b) + lambda(b)

[0029] The server sorts the deep blocks in descending order according to s(b), and selects the top K_deep(u,t) deep blocks with the highest scores under the budget K_deep(u,t) to form a set A(u,t) and sends it to the client; at the same time, an exploration rate eps(t) is introduced, which makes uniform random selection in S_deep with the probability of eps(t), and selects according to the sorting priority score with the probability of 1-eps(t).

[0030] Step 6: Local training using block-wise methods on the client side;

[0031] Step 7: Backhaul and Server Aggregation;

[0032] Step 8: Multi-source feedback statistics and time window smoothing: The server calculates the real reward real_reward and proxy reward proxy_reward for each deep block within a time window of length W, and uses exponential moving average to discount the historical feedback within the window to obtain the smoothed feedback estimate r_hat(b,t); the smoothing coefficient beta is used to assign weights between the current round of feedback and the historical feedback.

[0033] Step 9: The Covering Fairness Constraint module updates the probability distribution P through probabilistic smoothing and covering fairness constraints;

[0034] The server updates the state variables mu(b) and sigma2(b) of the deep blocks based on r_hat(b,t), and also updates the coverage constraint weight lambda(b); the server maintains the selection history of the most recent W rounds for each deep block and calculates the recent coverage f(b) of that block; the system sets a target coverage level c_target, and if the coverage of a block is consistently lower than c_target, then lambda(b) is gradually increased.

[0035] lambda(b)=clip(lambda(b)+cov_lr(c_target-f(b)),0,lambda_max)

[0036] Where cov_lr is a smaller learning rate, lambda_max is an upper bound, and clip represents the clipping function; meanwhile, gap(b) is updated according to whether it is selected, incrementing by one if it is not selected and clearing to zero if it is selected.

[0037] Step 10: Bandit feedback on build and block count budget status update;

[0038] Step 11: Proceed to the next round.

[0039] Furthermore, in step one, the backbone network is divided into B structural blocks in a forward sequence, and each block consists of several consecutive layers.

[0040] Furthermore, in step two, the server selects a set U(t) of clients to participate in training from all clients in round t. For each selected client u, the server first calculates three normalized capability scores: computing power h_comp(u), available memory h_mem(u), and uplink bandwidth h_comm(u), all ranging from 0 to 1. This yields the comprehensive capability score C(u).

[0041] C(u)=0.5h_comp(u)+0.3h_mem(u)+0.2h_comm(u)

[0042] The comprehensive ability score C(u), after being clipped and normalized, falls between 0 and 1;

[0043] The server sets two thresholds, tau1 and tau2, to divide clients into three categories: weak, medium, and strong. It also configures the range of blocks that client u can select in this round [k_min(u), k_max(u)].

[0044] When C(u) is less than or equal to tau1, let k_min(u) = 1 and k_max(u) = min(2, K_max); when tau1 is less than C(u) and C(u) is less than tau2, let k_min(u) = min(2, K_max) and k_max(u) = min(3, K_max); when C(u) is greater than or equal to tau2, let k_min(u) = min(3, K_max) and k_max(u) = min(4, K_max), where K_max is the maximum number of blocks allowed in a single round.

[0045] Furthermore, in step three, at the beginning of each training round, the server randomly selects an integer within the interval [k_min(u), k_max(u)] for client u as the block count budget alpha(u,t) for that round; the server maintains two state variables for each client u: p_mean(u,m) represents the historical feedback mean of selecting block count m, and n_count(u,m) represents the cumulative number of times block count m is selected; in the t-th round, V(u,m,t) is calculated for each candidate m:

[0046] V(u,m,t)=p_mean(u,m)+sqrt(ln(t+1) / (n_count(u,m)+1))

[0047] V(u,m,t) is the decision value used in the t-th round to compare different candidate block numbers m; let alpha(u,t) be the m that maximizes V(u,m,t).

[0048] Furthermore, in step four, the number of deep blocks to be selected is defined as:

[0049] K_deep(u,t)=alpha(u,t)-|S_fix|

[0050] Where |S_fix| represents the number of necessary shallow blocks; if K_deep(u,t) is less than 0, then set it to 0.

[0051] Furthermore, in step six, the client u receives the block parameter set sent by the server. When full(t)=1, it receives the full model parameters, and when full(t)=0, it receives the union of S_fix A(u,t). The client trains on local data for several training rounds.

[0052] Furthermore, in step nine, when updating the probability distribution, the server performs temperature softmax normalization on the score s(b) to obtain the base distribution P_base(b,t), with the temperature parameter tau_soft set to 1.0 to 2.0 to avoid an overly sharp distribution. Then, using a step size eta_p, P_base(b,t) is smoothly merged and normalized with the previous distribution P(b,t-1) to obtain the probability distribution P(b,t). Subsequently, the probability distribution P(b,t) is mixed with the exploration rate eps(t). Specifically, a uniform distribution U is constructed on the deep block set, and for each deep block_b, P_new(b) = (1-eps(t))*P(b,t) + eps(t)*U(b) is set to obtain a new probability distribution P_new.

[0053] Furthermore, in step ten, bandit feedback construction and block count budget state update: the server constructs a scalar feedback r_band(u,t) for each client u to update the block count budget bandit; the candidate selected in this round is denoted as m_star, i.e., m_star=alpha(u,t); then the server only updates the state quantity corresponding to m_star, updates p_mean(u,m_star) using an exponential moving average, and increments n_count(u,m_star) by one;

[0054] Step 11: Proceed to the next round: The server uses the updated global model parameters, deep probability distributions P_new and p_mean(u,m), and n_count(u,m) to enter the (t+1)th round of training.

[0055] To better achieve the objectives of this invention, an adaptive federated learning system is also provided, comprising a FedBR basic framework, a multi-source feedback statistics module, a block scheduling strategy module, and a coverage fairness constraint module. The multi-source feedback statistics module extracts and summarizes block-level semantic feedback from the real rewards and agent rewards returned by the client, providing a unified semantic feedback input for the block scheduling strategy module and the coverage fairness constraint module.

[0056] To better achieve the objectives of this invention, the present invention also provides a computer storage medium for storing program data, which, when executed by a computer, is used to implement the semantic feedback-guided structure-adaptive federated learning method.

[0057] Without altering the FedBR's basic block-wise pipeline, block-level regularization, and distillation methods, this invention, through the aforementioned strategy closed-loop, achieves the following improvements compared to the original continuous tail block scheme in typical heterogeneous and strongly non-independent identically distributed scenarios:

[0058] 1. This invention introduces a probabilistic deep block scheduling strategy. After determining the client's block budget k, instead of fixedly selecting the last k consecutive blocks, this invention introduces a probability distribution P of deep blocks. Sampling is performed on the deep block set according to P to obtain a subset of deep blocks to be deployed in this round, while retaining a certain proportion for random exploration. In this way, the deployment of deep blocks is no longer fixed to a continuous tail segment, but can gradually favor better-performing block combinations based on training feedback, forming a learnable probabilistic scheduling strategy. This allows the system to gradually favor better-performing block combinations based on accumulated feedback, rather than being fixed to a continuous tail segment, thus demonstrating a certain degree of online adaptive capability in experimental scenarios.

[0059] 2. This invention employs a non-stationary feedback smoothing mechanism using a time window and exponential moving average (EMA). On one hand, after local training on the client, the server not only collects the real reward of the selected block (e.g., loss reduction or accuracy improvement during training), but also evaluates the auxiliary output of all deep blocks using a small number of probe batches to construct a proxy reward, allowing unselected blocks to receive counterfactual feedback. On the other hand, the server statistically analyzes the multi-source feedback within a fixed-length time window and uses an exponential moving average to discount historical feedback within the window, obtaining a recent dominant feedback estimate r_hat, which is then used to update the probability policy P. Unlike existing schemes that use the client or data items as arms in a bandit (multi-armed gambling machine model), this invention constructs multi-source feedback at the block level and uses a time window and EMA to smooth and reduce the impact of single-round noise and partial observations on policy updates, making policy updates more stable and reducing the frequency of policy oscillations and extreme biases.

[0060] 3. This invention introduces probability distribution smoothing and coverage fairness constraints when updating the probability distribution P. Specifically, to reduce the situation where deep blocks have extremely low selection probabilities for a long time, this invention introduces two types of constraints when updating the probability distribution P: First, smoothing or temperature adjustment of policy parameters is performed to prevent the probability distribution from rapidly collapsing to a very small number of blocks due to a small number of high-reward samples. Second, coverage constraints are constructed based on the historical selection frequency of each block, providing certain compensation for long-term unselected blocks during updates. This invention clearly distinguishes between the two situations of "long-term non-selection" and "poor performance," and does not simply regard low-frequency blocks as invalid structures, but rather as candidates that are currently under-observed and require further exploration. The role of coverage constraints is, on the one hand, to avoid extreme starvation situations, and on the other hand, to deliberately preserve the exploration space for such structures, so that potentially valuable blocks are not completely abandoned by the policy prematurely. Through probability distribution smoothing and coverage fairness constraints, the extreme situation of deep blocks being completely unselected for a long time is significantly reduced, and the overall training participation of deep blocks is improved. Attached Figure Description

[0061] To more clearly illustrate the technical solutions in the embodiments of the present invention or the prior art, the accompanying drawings used in the description of the embodiments or the prior art will be briefly introduced below. Obviously, the drawings described below are merely some embodiments of the present invention. For those skilled in the art, other drawings can be obtained based on these drawings without any creative effort.

[0062] Figure 1 This is a framework diagram of a semantic feedback-guided structure-adaptive federated learning method according to the present invention;

[0063] Figure 2 This is a schematic diagram of block-level multi-source feedback and time window smoothing.

[0064] Figure 3 This is a comparison of the accuracy of this invention with other algorithms on the CIFAR-10 test set.

[0065] Figure 4 This is a comparison of the loss values ​​of the present invention with other algorithms on the CIFAR-10 test set.

[0066] Figure 5 This is a comparison of the accuracy of the present invention with other algorithms on the CIFAR-100 test set.

[0067] Figure 6 This is a comparison of the loss values ​​of the present invention with other algorithms on the CIFAR-100 test set.

[0068] Figure 7These are the results of ablation experiments. FULL indicates probabilistic ablation + windowing + ablation; Prob indicates any probabilistic ablation is possible; Prob Plus Window indicates probabilistic ablation plus windowing; Prob Plus Coverage indicates probabilistic ablation plus coverage constraints. Detailed Implementation

[0069] To make the objectives, technical solutions, and advantages of the embodiments of the present invention clearer, the technical solutions of the embodiments of the present invention will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are only some, not all, of the embodiments of the present invention. All other embodiments obtained by those skilled in the art based on the embodiments of the present invention without creative effort are within the scope of protection of the present invention.

[0070] Example 1: A semantic feedback-guided structure-adaptive federated learning method, the specific steps of which are as follows:

[0071] Step 1: Model Blocking

[0072] The backbone network is divided into B structural blocks in a forward sequence. Each block consists of several consecutive layers, keeping the original network topology unchanged.

[0073] Step 2: Assess client capabilities and determine candidate block count ranges.

[0074] In round t, the server selects a set U(t) of clients to participate in training from all clients. For each selected client u, the server first calculates three normalized capability scores: computing power h_comp(u), available memory h_mem(u), and uplink bandwidth h_comm(u), all ranging from 0 to 1. This yields the comprehensive capability score C(u):

[0075] C(u)=0.5h_comp(u)+0.3h_mem(u)+0.2h_comm(u)

[0076] The comprehensive ability score C(u), after being clipped and normalized, falls between 0 and 1.

[0077] The server sets two thresholds, tau1 and tau2, for example, tau1 is 0.45 and tau2 is 0.75, in order to divide the clients into three levels: weak, medium and strong, and configures the range of blocks that can be selected in this round for client u [k_min(u), k_max(u)].

[0078] When C(u) is less than or equal to tau1, let k_min(u) = 1 and k_max(u) = min(2, K_max);

[0079] When tau1 is less than C(u) and C(u) is less than tau2, let k_min(u) = min(2, K_max) and k_max(u) = min(3, K_max);

[0080] When C(u) is greater than or equal to tau2, let k_min(u) = min(3, K_max) and k_max(u) = min(4, K_max), where K_max is the maximum number of blocks allowed in a single round.

[0081] Step 3: Decision on the number of blocks budget alpha(u,t)

[0082] At the start of each training round, the server randomly selects an integer from the interval [k_min(u), k_max(u)] for client u, which serves as the block count budget alpha(u,t) for that round. This method employs upper confidence bound bandit decision-making on candidate set m belonging to [k_min(u), k_max(u)]. The server maintains two state variables for each client u: p_mean(u,m) represents the historical feedback mean of selecting block count m, and n_count(u,m) represents the cumulative number of times block count m is selected. In round t, V(u,m,t) is calculated for each candidate m:

[0083] V(u,m,t)=p_mean(u,m)+sqrt(ln(t+1) / (n_count(u,m)+1))

[0084] V(u,m,t) is the "decision value" used in round t to compare different candidate blocks m; let alpha(u,t) be the m that maximizes V(u,m,t). To ensure initial exploration, each candidate m can be selected at least once in the first few rounds.

[0085] Step 4: Determining the Full Round of Model Training and Generating the Block Set

[0086] The server maintains a full-round mechanism to periodically calibrate the alignment of different blocks and the feedback scale. Let `full(t)` denote whether round t is a full round. When `full(t) = 1`, the server sends all B blocks to the client. When `full(t) = 0`, the server first sends the necessary shallow blocks, denoted as `S_fix`, to ensure stable alignment of the basic representation. The remaining blocks are selected from the deep block set `S_deep`. The number of deep blocks to be selected is defined as:

[0087] K_deep(u,t)=alpha(u,t)-|S_fix|

[0088] Where |S_fix| represents the number of necessary shallow blocks. If K_deep(u,t) is less than 0, then set it to 0.

[0089] Step 5: The block scheduling strategy module performs probabilistic deep block selection and distribution.

[0090] When full(t) = 0, the server selects K_deep(u,t) blocks from the deep block set S_deep and sends them to the client u. For this purpose, the server maintains four state variables for each deep block_b: mu(b) represents the block's mean advantage or smoothed payoff estimate, sigma2(b) represents the block's uncertainty variance, lambda(b) represents the weight covering the fairness constraint, and gap(b) represents the number of rounds the block has gone through since its last selection. The server also sets a lower variance bound sigmafloor2, a time window W, a stale compensation coefficient stale_gamma, and a compensation upper bound stale_cap. In each round, a perturbation xi(b) is sampled from a Gaussian distribution with a mean of 0 and a variance not less than sigmafloor2 to construct a random advantage sample.

[0091] theta(b)=mu(b)+xi(b)+stale_gamma min(gap(b) / W,stale_cap)

[0092] The sorting priority score is obtained by overlaying the covering constraint terms:

[0093] s(b) = theta(b) + lambda(b)

[0094] The server sorts the deep blocks in descending order according to s(b), and selects the top K_deep(u,t) deep blocks with the highest scores under the budget K_deep(u,t) to form a set A(u,t) and sends it to the client.

[0095] To balance exploration and utilization, an exploration rate eps(t) is introduced. Uniform random selection is performed in S_deep with a probability of eps(t), and selection is performed according to the above scores with a probability of 1-eps(t), thereby avoiding premature collapse of the probability distribution.

[0096] Step Six: Local training of block-wise methods on the client side

[0097] The client u receives the block parameter set from the server. When full(t) = 1, it receives the full model parameters; when full(t) = 0, it receives the union of S_fix, A(u,t). The client trains on local data for several epochs. The training objective follows the FedBR design, consisting of the main task loss, block-wise regularization, and block-wise knowledge distillation, used to reduce the learning bias caused by non-independent and identically distributed data.

[0098] Step 7: Backhaul and Server Aggregation

[0099] To align with the original FedBR workflow, after completing local training, the client sends back the complete local model parameters. The server then performs an aggregation update on the complete models sent back by each client to obtain a new global model. The non-full-round communication compression mainly stems from the server sending only a portion of the deep blocks downlink, while uplink still sends back the entire model.

[0100] Step 8: The multi-source feedback statistics module performs multi-source feedback statistics and time window smoothing.

[0101] After training, the client sends back feedback information to the server, in addition to model parameters, to update the scheduling strategy. For selected deep blocks, the client sends back the real reward (real_reward), such as changes in training loss or accuracy improvement. To ensure that unselected deep blocks also receive counterfactual information, the client evaluates the auxiliary output of deep blocks on a small probe batch, inputting their feature representations and high-level semantic information such as category predictions into a simple scoring head to construct a proxy reward (proxy_reward). The server calculates the real_reward and proxy_reward for each deep block within a time window of length W, fuses the two signals at the block granularity, and discounts the historical feedback within the window using an exponential moving average to obtain a smoothed feedback estimate r_hat(b,t). This r_hat(b,t) can be considered as a semantic feedback signal oriented towards structured scheduling. The smoothing coefficient beta is used to distribute weights between the current round's feedback and historical feedback, thereby suppressing single-round noise while preserving high-level semantic discriminative power.

[0102] In experiments, the time window length W is usually set to around 5 rounds, but in actual use, values ​​between 3 and 10 can all work. For the exponential moving average with block-level feedback, a beta (smoothing coefficient) between 0.2 and 0.4 shows relatively stable performance, with the default value usually set to 0.3.

[0103] Step 9: The Covering Fairness Constraint module updates the probability distribution P through probabilistic smoothing and covering fairness constraints.

[0104] The server updates the state variables mu(b) and sigma2(b) of the deep blocks based on r_hat(b,t), and also updates the coverage constraint weight lambda(b). The server maintains the selection history of the most recent W rounds for each deep block and calculates the recent coverage f(b) of that block. The system sets a target coverage level c_target; if the coverage of a block is consistently lower than c_target, lambda(b) is gradually increased according to the rules.

[0105] lambda(b)=clip(lambda(b)+cov_lr(c_target-f(b)),0,lambda_max)

[0106] Here, cov_lr is the smaller learning rate, lambda_max is the upper bound, and clip represents the clipping function. Meanwhile, gap(b) is updated based on whether it is selected; it increments by one if not selected and resets to zero if selected.

[0107] When updating the probability distribution, the server performs temperature softmax normalization on the score s(b) to obtain the base distribution P_base(b,t). The temperature parameter tau_soft is set to 1.0 to 2.0 to avoid an overly sharp distribution. Then, the step size eta_p is used to smoothly merge and normalize P_base(b,t) with the previous distribution P(b,t-1) to obtain the probability distribution P(b,t). Subsequently, the probability distribution P(b,t) is mixed with the exploration rate eps(t). Specifically, a uniform distribution U is constructed on the deep block set. For each deep block _b, let P_new(b) = (1-eps(t))*P(b,t) + eps(t)*U(b) to obtain the new probability distribution P_new.

[0108] The exploration rate eps(t) is maintained within a moderate range. In one implementation, eps(t) is adjusted between 0.05 and 0.3 based on the entropy of the current sampling distribution. When the distribution is relatively uniform, eps(t) is close to 0.05; when the distribution is clearly concentrated on a few blocks, eps(t) increases to close to 0.3 to encourage more exploration. Those skilled in the art can routinely adjust these parameters within the above range, taking into account client heterogeneity.

[0109] Step 10: Bandit feedback build and block count budget status update

[0110] The server constructs a scalar feedback r_band(u,t) for each client u to update the block count budget bandit. This feedback can consist of performance gains and costs, for example, using the current round's accuracy improvement DeltaAcc(u,t) or loss reduction as the gain, and the end-to-end latency Time(u,t) and current round's downlink traffic DownGB(u,t) as the cost, combined according to the weights w_acc, w_time, and w_down.

[0111] r_band(u,t)=w_acc DeltaAcc(u,t)-w_time Time(u,t)-w_down DownGB(u,t)

[0112] The candidate selected in this round is denoted as m_star, i.e., m_star = alpha(u,t). Subsequently, the server only updates the state variables corresponding to m_star, updates p_mean(u,m_star) using an exponential moving average, and increments n_count(u,m_star) by one, so that the decision alpha(u,t+1) in the next round can be adaptively adjusted based on historical feedback.

[0113] Step 11: Proceed to the next round

[0114] The server uses the updated global model parameters, deep probability distributions P_new and p_mean(u,m) and (n_count(u,m)) to enter the (t+1)th round of training, thus forming a closed-loop adaptive federated learning process.

[0115] Without altering the FedBR's basic block-wise pipeline, block-level regularization, and distillation methods, this invention, through the aforementioned closed-loop strategy, achieves the following improvements compared to the original continuous tail block scheme in typical heterogeneous and strongly non-independent identically distributed scenarios:

[0116] 1. This invention introduces a probabilistic deep block scheduling strategy. After determining the client's block budget k, instead of fixedly selecting the last k consecutive blocks, this invention introduces a probability distribution P of deep blocks. Sampling is performed on the deep block set according to P to obtain a subset of deep blocks to be deployed in this round, while retaining a certain proportion for random exploration. In this way, the deployment of deep blocks is no longer fixed to a continuous tail segment, but can gradually favor better-performing block combinations based on training feedback, forming a learnable probabilistic scheduling strategy. This allows the system to gradually favor better-performing block combinations based on accumulated feedback, rather than being fixed to a continuous tail segment, thus demonstrating a certain degree of online adaptive capability in experimental scenarios.

[0117] 2. This invention employs a non-stationary feedback smoothing mechanism using a time window and exponential moving average (EMA). On one hand, after local training on the client, the server not only collects the real reward of the selected block (e.g., loss reduction or accuracy improvement during training), but also evaluates the auxiliary output of all deep blocks using a small number of probe batches to construct a proxy reward, allowing unselected blocks to receive counterfactual feedback. On the other hand, the server statistically analyzes the multi-source feedback within a fixed-length time window and uses an exponential moving average to discount historical feedback within the window, obtaining a recent dominant feedback estimate r_hat, which is then used to update the probability policy P. Unlike existing schemes that use the client or data items as arms in a bandit (multi-armed gambling machine model), this invention constructs multi-source feedback at the block level and uses a time window and EMA to smooth and reduce the impact of single-round noise and partial observations on policy updates, making policy updates more stable and reducing the frequency of policy oscillations and extreme biases. In this way, the present invention transforms the response of samples in the deep feature space into block-oriented semantic feedback, enabling the probabilistic strategy to perceive the contribution of different structures to the quality of semantic representation and task discrimination ability during the update.

[0118] 3. This invention introduces probability distribution smoothing and coverage fairness constraints when updating the probability distribution P. Specifically, to reduce the situation where deep blocks have extremely low selection probabilities for a long time, this invention introduces two types of constraints when updating the probability distribution P: First, smoothing or temperature adjustment of policy parameters is performed to prevent the probability distribution from rapidly collapsing to a very small number of blocks due to a small number of high-reward samples. Second, coverage constraints are constructed based on the historical selection frequency of each block, providing certain compensation for long-term unselected blocks during updates. This invention clearly distinguishes between the two situations of "long-term non-selection" and "poor performance," and does not simply regard low-frequency blocks as invalid structures, but rather as candidates that are currently under-observed and require further exploration. The role of coverage constraints is, on the one hand, to avoid extreme starvation situations, and on the other hand, to deliberately preserve the exploration space for such structures, so that potentially valuable blocks are not completely abandoned by the policy prematurely. Through probability distribution smoothing and coverage fairness constraints, the extreme situation of deep blocks being completely unselected for a long time is significantly reduced, and the overall training participation of deep blocks is improved.

[0119] In summary, without increasing the number of model parameters, the strategy loop of this invention can usually bring about a more stable convergence process, and shows a certain improvement or more stable trend in terms of global accuracy, weak end evaluation, and minority class performance compared with the original continuous tail block scheme.

[0120] Example 2: An adaptive federated learning system, comprising the aforementioned FedBR framework, a multi-source feedback statistics module, a block scheduling strategy module, and a coverage fairness constraint module. The multi-source feedback statistics module extracts and summarizes block-level semantic feedback from the real and proxy rewards returned by the client, providing a unified semantic feedback input for the block scheduling strategy module and the coverage fairness constraint module.

[0121] Experimental Example

[0122] The performance of the proposed method (named FedBRC) was compared with four benchmark algorithms: FedAvg, FedProx, MOON, FedMLB, and FedBR. Compared to FedAvg, FedProx adds a proximate term between the global and local models to the loss function, making the local training process more stable. MOON combines model-level contrastive learning with FedAvg, using the similarity between model representations to correct the local model training on the client side. In the FedMLB algorithm, this method introduces multiple hybrid pathways to absorb more knowledge from the global model and mitigate the negative impact of non-independent identically distributed (non-IID) data. The performance of the proposed framework was evaluated using the evaluation accuracy.

[0123] Non-independent identically distributed (non-IID) degree Below, a comparison of the test accuracy and loss values ​​of different algorithms can be found. Figure 3-6 As can be seen, on the CIFAR-10 test set, FedBR's highest accuracy is 80.01%, and FedBRC's highest accuracy is 83.03%. On the CIFAR-100 test set, FedBR's highest accuracy is 51.49%, and FedBR's highest accuracy is 53.51%.

[0124] The results of the ablation experiment are shown below. Figure 7 The ablation experiment verified the complementary effects of the components.

[0125] Block scheduling strategy module: Prob, which only uses probabilistic deep scheduling, can break the fixed continuous tail segment delivery, but due to feedback noise and partial observation, its strategy update is still prone to oscillation and bias.

[0126] Multi-source feedback statistics module: The introduction of time window and exponential moving average Prob plus Window further reduces the impact of single-round noise on the strategy, making the convergence curve smoother and the drawdown less, indicating that the main contribution of this module is to improve stability.

[0127] Coverage Fairness Constraint Module: The introduction of coverage fairness constraints in Prob plus Coverage significantly improves convergence and final accuracy in the mid-to-late stages, indicating that coverage compensation can effectively alleviate block starvation and structural obsolescence, and avoid long-term non-update caused by probability distribution collapse.

[0128] The final combination of the three forms a closed-loop policy update mechanism, which makes the scheduling tendency learnable and the update more stable. Therefore, it is superior to any single module variant in terms of convergence speed and final accuracy.

[0129] exist The probability of each sub-block being distributed in rounds 1-200 is shown in the table below, based on the CIFAR100 training set trained on ResNet18:

[0130] Table 1

[0131]

[0132] It can be seen that the shallow Block0 is consistently issued with a probability of 1.00 to ensure alignment of basic representations and training stability. The issuance probabilities of deep Blocks 1 to 3 remain generally within the range of approximately 0.5 to 0.7, indicating that the block selection results are relatively fair and the coverage constraint effectively suppresses block starvation and structural obsolescence. Furthermore, the probabilities of each deep block exhibit phased changes across different windows; for example, Block 1 gradually decreases while Block 3 gradually increases, indicating that the strategy adaptively adjusts its selection bias based on accumulated feedback, demonstrating learnability.

[0133] exist Under the given conditions, the communication volume of different federated learning algorithms when training the CIFAR100 training set based on ResNet18 and achieving a model accuracy of 49% is shown in the table below:

[0134] Table 2

[0135]

[0136] As can be seen, when the model accuracy reaches 49%, the cumulative communication volume of FedBRC is 71.8 GB, which is lower than FedBR's 73.2 GB, a reduction of about 1.9%. At the same time, FedBRC is significantly lower than FedAvg, FedProx, MOON, and FedMLB, indicating that under the same target accuracy, this invention improves the effectiveness of each update, thereby achieving the same accuracy with less communication volume.

[0137] Non-independent identically distributed (non-IID) degree The impact of the interval parameter τ on the bandwidth overhead of the FedBR algorithm (based on the CIFAR100 dataset after 200 rounds of global training) is shown in the table below:

[0138] Table 3

[0139]

[0140] It can be seen that, for the same T, the cumulative communication volume of FedBRC is lower than that of FedBR when T is 2 to 5, with a difference of approximately 1.3GB to 1.7GB. This indicates that under the setting of a large full round interval, the present invention can effectively reduce the collapse and redundant transmission of deep block selection by probabilistic scheduling of deep blocks combined with coverage constraints and probabilistic smoothing, thereby achieving lower communication overhead during 200 rounds of training. For the case where T equals 1, the communication volume difference between FedBRC and FedBR is small, with FedBRC slightly higher. This indicates that when full rounds are triggered more frequently, the communication overhead of both is mainly dominated by full rounds, and the impact of the introduced probabilistic scheduling mechanism on the total bandwidth is weakened. However, the overall trend still reflects the advantage of the present invention in reducing unnecessary transmissions.

[0141] The above embodiments are only used to illustrate the technical solutions of the present invention, and are not intended to limit it. Although the present invention has been described in detail with reference to the foregoing embodiments, those skilled in the art should understand that modifications can still be made to the technical solutions described in the foregoing embodiments, or equivalent substitutions can be made to some of the technical features. Such modifications or substitutions will not cause the essence of the corresponding technical solutions to deviate from the spirit and scope of the technical solutions of the embodiments of the present invention.

Claims

1. A semantic feedback-guided structure-adaptive federated learning method, characterized in that, The specific steps are as follows: Step 1: Model segmentation; Step 2: Assess client capabilities and determine candidate block count ranges; Step 3: Decision on the block number budget alpha(u,t); Step 4: Determine the full model training round and generate the block set: Let full(t) represent whether the t-th round is the full model training round. When full(t) = 1, the server sends all B blocks to the client. When full(t)=0, the server first issues the necessary shallow blocks, and then selects the rest from the deep block set S_deep. Step 5: Probabilistic deep block selection and distribution When full(t) = 0, the server selects K_deep(u,t) blocks from the deep block set S_deep and sends them to the client u. The server maintains four types of state variables for each deep block_b: the mean or smoothed return estimate of the block's advantage, mu(b), the uncertainty variance of the block, sigma2(b), the weight of the fairness constraint, lambda(b), and the number of rounds the block has experienced since its last selection, gap(b). The server sets the lower limit of variance, sigmafloor2, the time window W, the stale compensation coefficient, stale_gamma, and the upper limit of compensation, stale_cap. In each round, the server first samples the perturbation xi(b) from a Gaussian distribution with a mean of 0 and a variance not less than sigmafloor2 to construct a random advantage sample. theta(b)=mu(b)+xi(b)+stale_gamma min(gap(b) / W,stale_cap) The sorting priority score is obtained by overlaying the covering constraint terms: s(b) = theta(b) + lambda(b) The server sorts the deep blocks in descending order according to s(b), and selects the top K_deep(u,t) deep blocks with the highest scores under the budget K_deep(u,t) to form a set A(u,t) and sends it to the client; at the same time, an exploration rate eps(t) is introduced, which makes uniform random selection in S_deep with the probability of eps(t), and selects according to the sorting priority score with the probability of 1-eps(t). Step 6: Local training using block-wise methods on the client side; Step 7: Backhaul and Server Aggregation; Step 8: Multi-source feedback statistics and time window smoothing: The server calculates the real reward real_reward and proxy reward proxy_reward for each deep block within a time window of length W, and uses exponential moving average to discount the historical feedback within the window to obtain the smoothed feedback estimate r_hat(b,t); the smoothing coefficient beta is used to assign weights between the current round of feedback and the historical feedback. Step 9: The Covering Fairness Constraint module updates the probability distribution P through probabilistic smoothing and covering fairness constraints; The server updates the state variables mu(b) and sigma2(b) of the deep blocks based on r_hat(b,t), and also updates the coverage constraint weight lambda(b); the server maintains the selection history of the most recent W rounds for each deep block and calculates the recent coverage f(b) of that block; the system sets a target coverage level c_target, and if the coverage of a block is consistently lower than c_target, then lambda(b) is gradually increased. lambda(b)=clip(lambda(b)+cov_lr(c_target-f(b)),0,lambda_max) Where cov_lr is a smaller learning rate, lambda_max is an upper bound, and clip represents the clipping function; meanwhile, gap(b) is updated according to whether it is selected, incrementing by one if it is not selected and clearing to zero if it is selected. Step 10: Bandit feedback on build and block count budget status update; Step 11: Proceed to the next round.

2. The semantic feedback-guided structure-adaptive federated learning method according to claim 1, characterized in that, In step one, the backbone network is divided into B structural blocks in forward order, and each block consists of several consecutive layers.

3. The semantic feedback-guided structure-adaptive federated learning method according to claim 2, characterized in that, In step two, the server selects a set of clients U(t) from all clients to participate in training in round t. For each selected client u, the server first calculates three normalized capability scores: computing power h_comp(u), available memory h_mem(u), and uplink bandwidth h_comm(u), all ranging from 0 to 1; thus, the comprehensive capability score C(u) is obtained. C(u)=0.5h_comp(u)+0.3h_mem(u)+0.2h_comm(u) The comprehensive ability score C(u), after being clipped and normalized, falls between 0 and 1; The server sets two thresholds, tau1 and tau2, to divide clients into three categories: weak, medium, and strong. It also configures the range of blocks that client u can select in this round [k_min(u), k_max(u)]. When C(u) is less than or equal to tau1, let k_min(u) = 1 and k_max(u) = min(2, K_max); when tau1 is less than C(u) and C(u) is less than tau2, let k_min(u) = min(2, K_max) and k_max(u) = min(3, K_max); when C(u) is greater than or equal to tau2, let k_min(u) = min(3, K_max) and k_max(u) = min(4, K_max), where K_max is the maximum number of blocks allowed in a single round.

4. The semantic feedback-guided structure-adaptive federated learning method according to claim 3, characterized in that, In step three, at the beginning of each training round, the server randomly selects an integer from the interval [k_min(u), k_max(u)] for client u as the block budget alpha(u,t) for that round; the server maintains two state variables for each client u, p_mean(u,m) representing the historical feedback mean of selecting block m, and n_count(u,m) representing the cumulative number of times block m is selected; in the t-th round, V(u,m,t) is calculated for each candidate m: V(u,m,t)=p_mean(u,m)+sqrt(ln(t+1) / (n_count(u,m)+1)) V(u,m,t) is the decision value used in the t-th round to compare different candidate block numbers m; let alpha(u,t) be the m that maximizes V(u,m,t).

5. The semantic feedback-guided structure-adaptive federated learning method according to claim 4, characterized in that, In step four, the number of deep blocks to be selected is defined as: K_deep(u,t)=alpha(u,t)-|S_fix| Where |S_fix| represents the number of necessary shallow blocks; if K_deep(u,t) is less than 0, then set it to 0.

6. The semantic feedback-guided structure-adaptive federated learning method according to claim 5, characterized in that, In step six, the client u receives the block parameter set sent by the server. When full(t)=1, it receives the full model parameters, and when full(t)=0, it receives the union of S_fix A(u,t). The client trains on local data for several training rounds.

7. The semantic feedback-guided structure-adaptive federated learning method according to claim 6, characterized in that, In step nine, when updating the probability distribution, the server performs temperature softmax normalization on the score s(b) to obtain the base distribution P_base(b,t). The temperature parameter tau_soft is set to 1.0 to 2.0 to avoid the distribution being too sharp. Then, the step size eta_p is used to smoothly merge and normalize P_base(b,t) with the previous distribution P(b,t-1) to obtain the probability distribution P(b,t). Then, the probability distribution P(b,t) is mixed with the exploration rate eps(t). Specifically, a uniform distribution U is constructed on the deep block set. For each deep block_b, let P_new(b) = (1-eps(t))*P(b,t) + eps(t)*U(b) to obtain the new probability distribution P_new.

8. The semantic feedback-guided structure-adaptive federated learning method according to claim 7, characterized in that, Step 10, Bandit Feedback Construction and Block Count Budget State Update: The server constructs a scalar feedback r_band(u,t) for each client u to update the block count budget bandit; the candidate selected in this round is denoted as m_star, i.e., m_star=alpha(u,t); then the server only updates the state variables corresponding to m_star, updates p_mean(u,m_star) using an exponential moving average, and increments n_count(u,m_star) by one; Step 11: Proceed to the next round: The server uses the updated global model parameters, deep probability distributions P_new and p_mean(u,m), and n_count(u,m) to enter the (t+1)th round of training.

9. An adaptive federated learning system, used in the method described in any one of claims 1 to 8, characterized in that, The system includes the FedBR basic framework, a multi-source feedback statistics module, a block scheduling strategy module, and a coverage fairness constraint module.

10. A computer storage medium, characterized in that, The computer storage medium is used to store program data, which, when executed by the computer, is used to implement the semantic feedback-guided structure-adaptive federated learning method as described in any one of claims 1 to 8.

Images