Federal learning-based semantic communication knowledge co-evolution method

Abstract

The invention relates to the technical field of semantic communication and federated learning, in particular to a semantic communication knowledge co-evolution method based on federated learning, which comprises the following steps: S1, pre-training and issuing a global model; s2, edge group training initialization and dynamic scheduling; s3, carrying out local training and edge aggregation on the client; s4, cross-edge global synchronous aggregation is carried out; and S5, a closed-loop iteration updating mechanism. According to the method, the intra-group asynchronous updating and the inter-group synchronous aggregation are combined, dynamic client selection and incremental sparsification are utilized on the edge side, and the model performance and the communication overhead are efficiently balanced. A joint scheduling framework based on Lyapunov optimization ensures long-term stability and resource controllability of a training process from a system level, finally, periodic cross-domain knowledge fusion effectively overcomes barriers caused by data heterogeneity, the final generalization ability of a global model is remarkably enhanced, and efficient and robust co-evolution is realized.

Description

Technical Field

[0001] This invention relates to the fields of semantic communication and federated learning, and in particular to a method for the collaborative evolution of semantic communication knowledge based on federated learning. Background Technology

[0002] Semantic communication replaces the original symbols by transmitting semantic features, which can effectively compress information and improve transmission efficiency. Deep learning models, due to their powerful feature extraction capabilities, are widely used to build end-to-end semantic communication systems and have achieved remarkable results in various scenarios such as text, speech, and images.

[0003] However, current research mainly focuses on end-to-end communication, which is difficult to meet the actual needs of multiple users. Semantic communication relies on the two communicating parties sharing a consistent knowledge base. In deep learning, the knowledge base is represented by model parameters. In a multi-user environment, user models need to be updated synchronously to prevent semantic shifts. However, centralized training has privacy risks and high costs. Federated learning provides a solution to this problem by protecting data privacy through distributed training and promoting model evolution.

[0004] In practical deployments, federated learning faces the dual challenges of training efficiency and communication costs. Especially in edge environments, heterogeneous devices cause significant differences. At the same time, the traditional modeling method based on edge servers makes it easy for models to get stuck in local optima and make it difficult to extract global low-frequency semantic information. To solve the above problems, it is necessary to design a semantic communication system architecture that supports asynchronous updates, efficient communication and cross-edge generalization capabilities. Summary of the Invention

[0005] The main objective of this invention is to provide a method for the collaborative evolution of semantic communication knowledge based on federated learning. The technical problem to be solved is: in a multi-user, heterogeneous device environment, how to continuously evolve a shared semantic model with limited communication resources and achieve global knowledge generalization across edge servers, thereby overcoming the problems of privacy leakage and high communication overhead caused by traditional centralized model training schemes.

[0006] To achieve the above objectives, the technical solution adopted by the present invention is as follows:

[0007] A method for the co-evolution of semantic communication knowledge based on federated learning includes the following steps:

[0008] S1. Global Model Pre-training and Distribution: The global semantic model collaboration server uses public data to jointly pre-train the downstream task model and semantic coding model to generate an initial global semantic model. Then, the initial model is distributed to all terminal devices in the corresponding group through each edge server as the starting point for local model updates.

[0009] S2. Edge group training initialization and dynamic scheduling: Each edge server periodically sends a unified initialization model and training parameters to the client. The client reports the device status (communication / computation latency). The edge server dynamically decides the number of clients participating in each round of aggregation based on the Lyapunov optimization framework and issues training instructions containing the initialization model and sparsity parameters.

[0010] S3. Client-side local training and edge aggregation: After receiving the model, the client performs local training, performs Top-K sparsification on the model update according to the specified sparsity, and uploads the compressed update to the edge server. The edge server judges the aggregation conditions. If the conditions are met, it performs model aggregation to update the global model. Otherwise, it caches the update and makes the client wait. This process is repeated until the maximum number of communication rounds is reached.

[0011] S4. Cross-edge global synchronous aggregation: During the predetermined global aggregation cycle, the collaborative server initiates a model collection instruction, waits for the edge server in the training phase to complete the current round of updates, collects each edge model, performs weighted fusion, generates a new global semantic model, and finally redistributes it to all terminal devices through the edge server.

[0012] S5. Closed-loop iterative update mechanism: The terminal device uses the updated global model to start a new round of training, continuously looping the complete process of edge group training initialization, local training, edge aggregation and global fusion, to achieve cross-domain knowledge sharing and improve model generalization ability.

[0013] Preferably, the training parameters in step S2 include the local update learning rate η, the number of local gradient descents E, and the local update batch size B.

[0014] Preferably, the device status information in step S2 includes: calculated delay. and communication delay Including computational delay The average time required for the device to complete one round of training is obtained by performing multiple tests based on the training information, and the communication latency is also calculated. The latency of transmitting the entire model to the edge service was tested multiple times and the average value was taken.

[0015] Preferably, in step S2, the process of issuing the start training command, uniformly initializing the model, and sending sparsity to the client, along with the edge server dynamically deciding the number of clients participating in each round of aggregation using the Lyapnouv optimization framework, specifically includes:

[0016] First, calculate the sparsity, which needs to increase with the number of communication rounds, for example:

[0017]

[0018] Where t is the current communication round, and k min The minimum sparsity is set to λ, where λ is the sparsity growth rate, and T is the value of T. interval The adjustment period is denoted by S, where S is the total number of model parameters.

[0019] Secondly, the lyapnouv optimization framework dynamically determines the number of clients participating in each round of aggregation, including optimizing model accuracy given the system's traffic and time budgets.

[0020]

[0021]

[0022]

[0023]

[0024] Among them, c t It is an exponential function of the global round t, where the base a satisfies 0 < a < 1, I t,i =1 indicates that client i communicates with the server in round t; otherwise, it is 0. The staleness τ of client i's model in round t is... t，i satisfy:

[0025]

[0026] C max T represents the client communication budget (in units of communication times). max For time budgeting, T t The time consumed in each round is T, where T is the total number of communication rounds.

[0027] Based on Lyapunov optimization, the time constraint and traffic constraint in the constraints are modeled as a virtual queue q. t，time and q t，comm queue q t,time satisfy:

[0028]

[0029] Queue q t,comm satisfy:

[0030]

[0031] Using the drift-penalty algorithm, the original problem... Transform into the following questions

[0032]

[0033] Where V is a weight parameter related to model performance;

[0034] In order to solve I t，i In each round, the clients are sorted in ascending order based on their remaining time. The calculation formula is as follows:

[0035]

[0036] Where T cur T represents the current time. last Indicates the time when the client starts training;

[0037] Assumption Let K represent the set of clients sorted in ascending order based on remaining time. t Decisions are made by gradually increasing the number of digits from 1 to N. Mid-front K t The client set formed by the client, the time consumed in the t-th communication round. Then we will T t Substituting into the optimization objective function, the drift plus penalty value is calculated and denoted as Y(K). t ), K t optimal value By comparing all possible K t The drift plus penalty between them is worth the cost, that is

[0038]

[0039] Preferably, in step S3, after each client receives the current global model and the global model version number, it performs semantic model training locally. After training, it calculates the sparsity according to the sparsity selection strategy and performs Top-K sparsification on the model update. The sparsified model update is then uploaded to the edge server. This specifically includes model training and calculating the model update, wherein model training includes:

[0040] x i,0 ←x t ,

[0041]

[0042] Where F i Describes the task loss function for client i. This indicates that client i is in the batch data ξ i,q The derivative on;

[0043] Computational model update:

[0044] △ i =x i,0-x i，Q

[0045] Top-K sparsity refers to retaining the k elements with the largest absolute values ​​during model updates and setting the remaining elements to 0.

[0046]

[0047] Here, the superscript (i) represents the i-th element, and thres is the k-th largest value of |Δ|.

[0048] Preferably, the polymerization conditions in step S3 include:

[0049] First, determine if the aggregation condition is met. This is based on whether the number of client updates received by the current edge server is greater than or equal to a preset number, i.e., K. t If the value is greater than or equal to K, then model aggregation is performed; otherwise, the cached model is updated and the server continues to wait. Model aggregation uses the following formula:

[0050]

[0051] Where η g The global learning rate;

[0052] After the model is aggregated, the cache array is cleared, and it is determined whether the current global communication round is greater than or equal to the maximum communication round, i.e., t≥T. If the condition is met, the aggregation is stopped, and the final global model is sent to all clients. Otherwise, the new global model is sent to the clients waiting for training to start the next round of training.

[0053] Compared with the prior art, the advantages and positive effects of the present invention are as follows:

[0054] 1. This invention cleverly balances model performance and communication costs through an asynchronous federated learning mechanism implemented within groups. The incremental sparsity strategy means that richer information flow is allowed in the early stages of training to quickly explore the model, while the amount of non-critical information transmitted is intelligently reduced as the model gradually converges. At the same time, the dynamic client selection mechanism ensures that at any point in time, the system prioritizes scheduling the device with the best state to participate in training and aggregation, avoiding the "bottleneck effect" caused by device heterogeneity. This dual optimization enables each edge group to continuously iterate its local model in the most efficient way within a limited communication resource budget, laying a solid foundation for the final global fusion.

[0055] 2. This invention employs a Lyapunov-optimized communication-performance joint scheduling framework, transforming long-term communication and time constraints into a real-time manageable virtual queue. It decomposes the complex global optimization problem into online decisions for each round, not only pursuing the maximization of model performance in a single update but also focusing on the stability and resource utilization of the entire training process. Through a drift-penalty algorithm, it makes a dynamic trade-off between improving model accuracy and system overhead. This precise application of control theory fundamentally ensures that the communication overhead of the entire system remains within a controllable range, while driving a steady improvement in model performance, achieving a synergistic effect of efficiency and effectiveness.

[0056] 3. This invention solves the inherent problems of data silos and knowledge limitations in federated learning through a periodic synchronous aggregation mechanism between groups. User groups on different edge servers often have unique data distributions, which can easily lead to "bias" in local models. Periodic global aggregation is like a cross-domain knowledge fusion. It integrates and refines the different "specialties" extracted from various local data to generate a more universal global semantic model. This mechanism effectively alleviates the local optima problem caused by data heterogeneity and significantly enhances the global generalization ability of the final model, enabling it to better serve diverse user scenarios. Attached Figure Description

[0057] Figure 1 This is a structure for a semantic communication knowledge co-evolution system based on federated learning;

[0058] Figure 2 This is a schematic diagram of the semantic communication knowledge collaborative evolution process in this invention;

[0059] Figure 3 The accuracy trend of asynchronous federated learning of semantic models under edge servers in this invention;

[0060] Figure 4 The peak signal-to-noise ratio trend of asynchronous federated learning of semantic models under edge servers in this invention;

[0061] Figure 5 This shows the trend of accuracy change of the global model after synchronous aggregation between groups in this invention.

[0062] Figure 6 This shows the peak signal-to-noise ratio (PSNR) trend of the global model after synchronous aggregation between groups in this invention. Detailed Implementation

[0063] The technical solution of the present invention will now be described with reference to the accompanying drawings.

[0064] Example 1, please refer to Figure 1-2This invention provides a technical solution: a method for the collaborative evolution of semantic communication knowledge based on federated learning, comprising the following steps:

[0065] S1. Global Model Pre-training and Distribution: The global semantic model collaboration server uses public data to jointly pre-train the downstream task model and semantic coding model to generate an initial global semantic model. Then, the initial model is distributed to all terminal devices in the corresponding group through each edge server as the starting point for local model updates.

[0066] S2. Edge group training initialization and dynamic scheduling: Each edge server periodically sends a unified initialization model and training parameters to the client. The client reports the device status (communication / computation latency). The edge server dynamically decides the number of clients participating in each round of aggregation based on the Lyapunov optimization framework and issues training instructions containing the initialization model and sparsity parameters.

[0067] S3. Client-side local training and edge aggregation: After receiving the model, the client performs local training, performs Top-K sparsification on the model update according to the specified sparsity, and uploads the compressed update to the edge server. The edge server judges the aggregation conditions. If the conditions are met, it performs model aggregation to update the global model. Otherwise, it caches the update and makes the client wait. This process is repeated until the maximum number of communication rounds is reached.

[0068] S4. Cross-edge global synchronous aggregation: During the predetermined global aggregation cycle, the collaborative server initiates a model collection instruction, waits for the edge server in the training phase to complete the current round of updates, collects each edge model, performs weighted fusion, generates a new global semantic model, and finally redistributes it to all terminal devices through the edge server.

[0069] S5. Closed-loop iterative update mechanism: The terminal device uses the updated global model to start a new round of training, continuously looping the complete process of edge group training initialization, local training, edge aggregation and global fusion, to achieve cross-domain knowledge sharing and improve model generalization ability.

[0070] The training parameters in step S2 include the local update learning rate η, the number of local gradient descent steps E, and the local update batch size B.

[0071] The device status information in step S2 includes: calculating delay. and communication delay

[0072] Including computational delay The average time required for the device to complete one round of training is obtained by performing multiple tests based on the training information, and the communication latency is also calculated. The latency of transmitting the entire model to the edge service was tested multiple times and the average value was taken.

[0073] The S2 step, which involves issuing the start training command, uniformly initializing the model, and distributing sparsity to the client, is further defined by the edge server dynamically determining the number of clients participating in each round of aggregation using the Lyapnouv optimization framework. Specifically, this includes:

[0074] First, calculate the sparsity, which needs to increase with the number of communication rounds, for example:

[0075]

[0076] Where t is the current communication round, and k min The minimum sparsity is set to λ, where λ is the sparsity growth rate, and T is the value of T. interval The adjustment period is used, and S is the total number of model parameters;

[0077] Secondly, the lyapnouv optimization framework dynamically determines the number of clients participating in each round of aggregation, including optimizing model accuracy given the system's traffic and time budgets.

[0078]

[0079]

[0080]

[0081]

[0082] Among them, c t It is an exponential function of the global round t, where the base a satisfies 0 < a < 1, I t，i =1 indicates that client i communicates with the server in round t; otherwise, it is 0. The staleness τ of client i's model in round t is... t，i satisfy:

[0083]

[0084] C max T represents the client communication budget (in units of communication times). max For time budgeting, T t The time consumed in each round is T, where T is the total number of communication rounds.

[0085] Based on Lyapunov optimization, the time constraint and traffic constraint in the constraints are modeled as a virtual queue q. t，time and q t，comm queue q t，time satisfy:

[0086]

[0087] Queue q t，comm satisfy:

[0088]

[0089] Using the drift-penalty algorithm, the original problem... Transform into the following questions

[0090]

[0091] Where V is a weight parameter related to model performance;

[0092] In order to solve I t，i In each round, the clients are sorted in ascending order based on their remaining time. The calculation formula is as follows:

[0093]

[0094] Where T cur T represents the current time. last Indicates the time when the client starts training;

[0095] Assumption Let K represent the set of clients sorted in ascending order based on remaining time. t Decisions are made by gradually increasing the number of digits from 1 to N. Mid-front K t The client set formed by the client, the time consumed in the t-th communication round. Then we will T t Substituting into the optimization objective function, the drift plus penalty value is calculated and denoted as Y(K). t ), K t optimal value By comparing all possible K t The drift plus penalty between them is worth the cost, that is

[0096]

[0097] In step S3, after each client receives the current global model and its version number, it performs semantic model training locally. After training, it calculates sparsity according to a sparsity selection strategy and performs Top-K sparsification on the model update. The sparsified model update is then uploaded to the edge server. This process specifically includes model training and calculating the model update. Model training includes:

[0098] x i,0 ←x t ,

[0099]

[0100] Where F i Describes the task loss function for client i. This indicates that client i is in the batch data ξ i，q The derivative on;

[0101] Computational model update:

[0102] △ i =x i,0 -x i,Q

[0103] Top-K sparsity refers to retaining the k elements with the largest absolute values ​​during model updates and setting the remaining elements to 0.

[0104]

[0105] Here, the superscript (i) represents the i-th element, and thres is the k-th largest value of |Δ|.

[0106] The polymerization conditions in step S3 include:

[0107] First, determine if the aggregation condition is met. This is based on whether the number of client updates received by the current edge server is greater than or equal to a preset number, i.e., K. t If the value is greater than or equal to K, then model aggregation is performed; otherwise, the cached model is updated and the server continues to wait. Model aggregation uses the following formula:

[0108]

[0109] Where η g The global learning rate;

[0110] After the model is aggregated, the cache array is cleared, and it is determined whether the current global communication round is greater than or equal to the maximum communication round, i.e., t≥T. If the condition is met, the aggregation is stopped, and the final global model is sent to all clients. Otherwise, the new global model is sent to the clients waiting for training to start the next round of training.

[0111] Example 2 applies the method from Example 1 to the following scenario.

[0112] Assume the system has M edge servers, each with a maximum of N clients, the total number of communication rounds in the edge server federated learning is T, and the maximum training time is T. max .

[0113] 1. Global semantic model pre-training and distribution

[0114] In the global semantic model pre-training process, the global semantic model collaborative server utilizes a public dataset to pre-train downstream task models (such as classification networks) and semantic encoding models (such as convolutional autoencoders) respectively, obtaining the initial global model parameters x. 0 The model sends instructions to model x 0 The data is distributed to all clients within the corresponding user group via each edge server, serving as the starting model for subsequent local updates.

[0115] 2. Intra-group asynchronous federated learning updates

[0116] Federated learning within the group mainly includes four sub-steps: training information distribution and status reporting, dynamic client selection and sparsity increment strategy setting, local training and Top-K sparsification, and edge model aggregation.

[0117] a. Training information distribution and status reporting

[0118] The edge server periodically broadcasts the local learning rate η to all its subordinate clients. l The client measures the local computation latency multiple times based on the following parameters: local iteration count Q, batch size b, and sparsity S (i.e., full transmission). and communication delay The average value is then taken and reported to the edge server.

[0119] b. Dynamic client selection and sparsity increment strategy settings

[0120] Edge servers utilize the Lyapunov optimization framework to optimize communication budget C max and time budget T max Each is constructed as a virtual queue:

[0121]

[0122]

[0123] Then calculate the client's remaining time:

[0124]

[0125] Where T cur T represents the current time. last Indicates the time when the client starts training;

[0126] Generate a set in ascending order of remaining client time. Enumerate K t For numbers = 1, ..., N, calculate the drift penalty value for each:

[0127]

[0128] And take the minimum value corresponding to The number of clients participating in this round of aggregation;

[0129] To control upload sparsity, the sparsity rate for each client is calculated:

[0130] δ t，i =δ min +λ[t / T interval ], k t，i =δ t，i S

[0131] forward The client sends a training command: x t sparsity k t，i Local learning rate η l Local iteration count Q, batch size b;

[0132] c. Local training and Top-K sparsity

[0133] Client i receives the new global model x t Then, perform a local update:

[0134] x i,0 ←x t ,

[0135]

[0136] After training is complete, the computational model is updated:

[0137] △ i =x i,0 -x i，Q

[0138] Press k t,i Compute Top-K sparsity: Preserve Δ i k with the largest absolute value t，i Set one element to zero and the rest to zero, then upload the sparse update to the edge server;

[0139] d. Edge model aggregation

[0140] The edge server receives sparse updates from clients, if it has received KB of updates. t satisfy Then, according to:

[0141]

[0142] Perform aggregation and clear the cache; otherwise, continue caching and wait.

[0143] If the current global round t < T, then the new model x t+1 and sparsity ratio δt+1，i Distribute the training to clients that have already completed the training and proceed to the next round; otherwise, end the current training.

[0144] 3. Cross-edge server synchronization aggregation

[0145] The global semantic model collaboration server sends model collection requests to all edge servers at predetermined intervals. It then waits for the edge nodes currently undergoing intra-group training to complete their current round of updates, while the remaining nodes pause their new round of training. Next, it collects the models reported by M edge servers, takes the average value, and fuses them to generate the global model.

[0146] Will The knowledge is distributed to each edge server, which then redistributes it to all clients, completing a global knowledge sharing and generalization process.

[0147] Through the above implementation methods, this invention integrates incremental sparsity, dynamic client selection, and Lyapunov optimization decision-making in a multi-user, heterogeneous device environment, achieving efficient asynchronous updates within groups and synchronous aggregation across domains, thus ensuring the continuous evolution and global generalization of the semantic model under limited communication resources.

[0148] Based on the above, experiments can be conducted to compare the effects of the semantic communication knowledge co-evolution based on federated learning with those of traditional federated learning algorithms, and then draw conclusions.

[0149] First, we assume the downstream task is a classification task based on the publicly available image dataset CIFAR10, and implement asynchronous federated learning in PyTorch. The classification model uses a convolutional neural network, and the semantic encoding model is a convolutional autoencoder model. To illustrate the performance of the proposed asynchronous federated learning method based on incremental sparsity and dynamic synchronization, we selected the fully asynchronous algorithm FedAsync, the semi-asynchronous aggregation algorithm FedBuff (with the number of aggregation clients set to 5 or 10), and the synchronous method FedAvg as benchmark methods. We assume there are 50 devices performing federated learning on 10 edge servers.

[0150] Figure 3 The accuracy of the semantic coding model on the test set over time is depicted. It can be seen that the proposed algorithm achieves higher accuracy during semantic model training, and after the time budget is exhausted, the proposed algorithm reduces communication overhead by approximately 7.2% compared to Fedbuff-10.

[0151] Figure 4 The peak signal-to-noise ratio (PSNR) of the semantic coding model on the test set is depicted over time. It can be seen that although the proposed algorithm's PSNR decreased during semantic model training, this is because the semantic model was trained with a greater focus on the classification objective.

[0152] Figure 5 The accuracy of the semantic encoding model on the test set on the global semantic model collaboration server is depicted over time. It can be seen that the accuracy gradually increases with the periodic communication of the semantic model.

[0153] Figure 6 The peak signal-to-noise ratio (PSNR) of the semantic encoding model on the global semantic model collaboration server over time is depicted. It can be seen that the PSNR gradually increases with the periodic communication of the semantic model. The initial decrease is because the initial semantic model was well-pre-trained on the public dataset, but at this point its classification accuracy on downstream tasks is poor (see...). Figure 3 The degradation occurred because the system did not fully adapt to the new data distribution during initial training on new data.

[0154] It should be noted that in the attached diagrams 3-4, the blue line represents fedasync, the orange line represents feduf-5, the red line represents feduf-10, the gray line represents fedavg, and the yellow line represents proposed.

[0155] The above description is merely a specific embodiment of the present invention, but the scope of protection of the present invention is not limited thereto. Any variations or substitutions that can be easily conceived by those skilled in the art within the technical scope disclosed in the present invention should be included within the scope of protection of the present invention. Therefore, the scope of protection of the present invention should be determined by the scope of the claims.

Claims

1. A method for the co-evolution of semantic communication knowledge based on federated learning, characterized in that, The system includes: S1. Global Model Pre-training and Distribution: The global semantic model collaboration server uses public data to jointly pre-train the downstream task model and semantic coding model to generate an initial global semantic model. Then, the initial model is distributed to all terminal devices in the corresponding group through each edge server as the starting point for local model updates. S2. Edge group training initialization and dynamic scheduling: Each edge server periodically sends a unified initialization model and training parameters to the client. The client reports the device status (communication / computation latency). The edge server dynamically decides the number of clients participating in each round of aggregation based on the Lyapunov optimization framework and issues training instructions containing the initialization model and sparsity parameters. S3. Client-side local training and edge aggregation: After receiving the model, the client performs local training, performs Top-K sparsification on the model update according to the specified sparsity, and uploads the compressed update to the edge server. The edge server judges the aggregation conditions. If the conditions are met, it performs model aggregation to update the global model. Otherwise, it caches the update and makes the client wait. This process is repeated until the maximum number of communication rounds is reached. S4. Cross-edge global synchronous aggregation: During the predetermined global aggregation cycle, the collaborative server initiates a model collection instruction, waits for the edge server in the training phase to complete the current round of updates, collects each edge model, performs weighted fusion, generates a new global semantic model, and finally redistributes it to all terminal devices through the edge server. S5. Closed-loop iterative update mechanism: The terminal device uses the updated global model to start a new round of training, continuously looping the complete process of edge group training initialization, local training, edge aggregation and global fusion, to achieve cross-domain knowledge sharing and improve model generalization ability.

2. The semantic communication knowledge co-evolution method based on federated learning according to claim 1, characterized in that: The training parameters in step S2 include the local update learning rate η, the number of local gradient descent steps E, and the local update batch size B.

3. The semantic communication knowledge co-evolution method based on federated learning according to claim 1, characterized in that: The device status information in step S2 includes: calculating delay. and communication delay Including computational delay The average time required for the device to complete one round of training is obtained by performing multiple tests based on the training information, and the communication latency is also calculated. The latency of transmitting the entire model to the edge service was tested multiple times and the average value was taken.

4. The semantic communication knowledge co-evolution method based on federated learning according to claim 3, characterized in that: The S2 step, which involves issuing the start training command, uniformly initializing the model, and distributing sparsity to the client, is specifically implemented by the edge server dynamically determining the number of clients participating in each round of aggregation using the Lyapnouv optimization framework. First, calculate the sparsity, which needs to increase with the number of communication rounds, for example: Where t is the current communication round, and k min The minimum sparsity is set to λ, where λ is the sparsity growth rate, and T is the value of T. interval The adjustment period is used, and S is the total number of model parameters; Secondly, the lyapnouv optimization framework dynamically determines the number of clients participating in each round of aggregation, including optimizing model accuracy given the system's traffic and time budgets. Among them, c t It is an exponential function of the global round t, where the base a satisfies 0 < a < 1, I t，i =1 indicates that client i communicates with the server in round t; otherwise, it is 0, representing the staleness τ of client i's model in round t. t，i satisfy: C max T represents the client communication budget (in units of communication times). max For time budgeting, T t The time consumed in each round is T, where T is the total number of communication rounds. Based on Lyapunov optimization, the time constraint and traffic constraint in the constraints are modeled as a virtual queue q. t，time and q t，comm queue q t，time satisfy: Queue q t，comm satisfy: Using the drift-penalty algorithm, the original problem... Transform into the following questions Where V is a weight parameter related to model performance; In order to solve I t，i In each round, the clients are sorted in ascending order based on their remaining time. The calculation formula is as follows: Where T cur T represents the current time. last Indicates the time when the client starts training; Assumption Let K represent the set of clients sorted in ascending order based on remaining time. t Decisions are made by gradually increasing the number of digits from 1 to N. Mid-front K t The client set formed by the client, the time consumed in the t-th communication round. Then we will T t Substituting into the optimization objective function, the drift plus penalty value is calculated and denoted as Y(K). t ), K t optimal value By comparing all possible K t The drift plus penalty between them is worth the cost, that is 5. The semantic communication knowledge co-evolution method based on federated learning according to claim 1, characterized in that: In step S3, after each client receives the current global model and its version number, it performs semantic model training locally. After training, it calculates sparsity according to a sparsity selection strategy and performs Top-K sparsification on the model update. The sparsified model update is then uploaded to the edge server. This process specifically includes model training and calculating the model update. Model training includes: x i,0 ←x t , Where F i Describes the task loss function for client i. This indicates that client i is in the batch data ξ i,q The derivative on; Computational model update: Δ i =x i,0 -x i,Q Top-K sparsity refers to retaining the k elements with the largest absolute values ​​during model updates and setting the remaining elements to 0. Here, the superscript (i) represents the i-th element, and thres is the k-th largest value of |Δ|.

6. The semantic communication knowledge co-evolution method based on federated learning according to claim 1, characterized in that: The polymerization conditions in step S3 include: First, determine if the aggregation condition is met. This is based on whether the number of client updates received by the current edge server is greater than or equal to a preset number, i.e., K. t If the value is greater than or equal to K, then model aggregation is performed; otherwise, the cached model is updated and the server continues to wait. Model aggregation uses the following formula: Where η g The global learning rate; After the model is aggregated, the cache array is cleared, and it is determined whether the current global communication round is greater than or equal to the maximum communication round, i.e., t≥T. If the condition is met, the aggregation is stopped, and the final global model is sent to all clients. Otherwise, the new global model is sent to the clients waiting for training to start the next round of training.

Images