A prototype learning-based split federated learning communication optimization method and system

Abstract

This invention relates to the fields of wireless networks, edge computing, and distributed machine learning, and particularly to a method and system for optimizing communication in split-feeded learning based on prototype learning. The proposed method for optimizing communication in split-feeded learning, without directly uploading the original data, replaces the uplink transmission object in split-feeded learning with per-sample high-dimensional segmentation features, and uses category-level local prototypes and sample numbers. Furthermore, it introduces classification loss and local-global prototype alignment loss for joint training on the server side. This method can significantly reduce uplink traffic in wireless networks while maintaining the accuracy of competitive models, and is particularly suitable for wireless edge learning scenarios with limited uplink capacity and highly non-independent and identically distributed client data.

Description

Technical Field

[0001] This invention relates to the fields of wireless networks, edge computing, and distributed machine learning, and particularly to a method and system for optimizing communication through split federated learning based on prototype learning. More specifically, this invention utilizes prototype learning to compress client-side hierarchical features into compact semantic prototypes by category, and then performs joint training on the server side by combining classification loss and local-global prototype alignment loss, thereby reducing uplink transmission volume and enhancing the stability of collaborative learning in scenarios with non-independent and identically distributed data. Background Technology

[0002] Edge computing enables machine learning tasks to be executed at the network edge, thus supporting low-latency intelligent decision-making. Federated learning achieves collaborative modeling through local training on clients and aggregation of model parameters on a central server, avoiding the direct uploading of raw data, and is therefore widely used in privacy-preserving wireless intelligent systems. However, traditional federated learning typically requires each client to train a complete deep model, which imposes high computational, storage, and energy burdens on mobile terminals, in-vehicle devices, sensors, and other resource-constrained devices.

[0003] Split Federated Learning combines the ideas of split learning and federated learning, dividing the model into client-side sub-models and server-side sub-models. The client is only responsible for the computation of the first few layers of the model and uploads the intermediate activation features output from the split layers to the server, which then continues to complete the subsequent forward and backward propagation. This mechanism reduces the requirements for the client to perform full model training and is suitable for deployment on wireless terminals with limited computing power.

[0004] However, split federated learning requires the client to repeatedly upload high-dimensional split features for each sample in each mini-batch during training and receive the corresponding gradients from the server. Since split features are typically high-dimensional, and the training process involves numerous communication rounds and mini-batch iterations, the resulting uplink communication overhead is considerable. In wireless networks, uplink bandwidth and power resources are usually more limited; excessive uplink load increases transmission latency, reduces spectrum utilization efficiency, and may affect overall training convergence.

[0005] Existing research has attempted to reduce the communication burden of split federated learning through methods such as activation quantization, spatial downsampling, semantic compression, model split point optimization, bandwidth allocation, or hierarchical training. However, most of these methods still revolve around compressing or scheduling per-sample split features, and the basic unit of their uplink transmission objects remains the sample-level feature. Therefore, when the number of local mini-batch samples on the client is large or the dimension of the split feature is high, the communication bottleneck remains significant.

[0006] On the other hand, prototype learning can aggregate the representations of samples of the same category in the embedding space into category semantic centers. Category prototypes can preserve category-level discriminative information while reducing redundant representations among samples of the same category. Introducing prototype learning into split federated learning has the potential to transform the transmitted objects from sample-level high-dimensional segmentation features into category-level compact prototypes, thereby changing the way uplink traffic grows. Summary of the Invention

[0007] The technical problem this invention aims to solve is that existing split federated learning in wireless networks relies on uploading high-dimensional split features sample by sample, resulting in high uplink communication overhead and high training latency. Furthermore, it is susceptible to statistical heterogeneity when client data is not independently and identically distributed. To address this, this invention proposes a prototype-assisted split federated learning mechanism, whereby the client only uploads local category prototypes aggregated by category and the number of category samples. On the server side, model performance is maintained through joint training of classification and prototype alignment.

[0008] This invention relates to a prototype-based split federated learning communication optimization method, applied to a wireless edge learning system comprising multiple clients and a server. The method includes: the server sending client-side sub-model parameters and server-side sub-model parameters obtained from global model partitioning to selected clients; the clients using the client-side sub-models to perform forward computation on local mini-batch samples to obtain stratified features; the clients aggregating the stratified features according to sample categories to obtain local category prototypes and the number of category samples corresponding to each observed category; the clients uploading the local category prototypes and the number of category samples to the server; the server calculating a classification loss based on the local category prototypes, performing weighted aggregation of local category prototypes of the same category uploaded by multiple clients based on the number of category samples to update the global category prototype, and calculating a prototype alignment loss between the local category prototypes and the corresponding global category prototypes; the server constructing a joint training objective based on the classification loss and the prototype alignment loss, updating the server-side sub-model, and returning the prototype gradients corresponding to the observed categories of each client to the corresponding clients; the clients backpropagating based on the prototype gradients via prototype aggregation relationships to update their client-side sub-models.

[0009] In one implementation, the local category prototype is the mean vector of the stratified features corresponding to the same category in the current mini-batch samples.

[0010] In one implementation, the client only uploads the local category prototype and the number of category samples corresponding to the categories that actually appear in the current mini-batch, so that the uplink transmission volume changes with the number of observed categories, rather than increasing linearly with the total number of mini-batch samples.

[0011] In one implementation, the classification loss is the cross-entropy loss obtained by the server-side classifier after predicting the category of the local category prototype, and is weighted and averaged according to the number of samples in each category.

[0012] In one implementation, the prototype alignment loss is the distance loss between the local category prototype and the global category prototype of the same category, said distance loss including the squared Euclidean distance loss.

[0013] In one implementation, the joint training objective is a weighted sum of the classification loss and the prototype alignment loss.

[0014] In one implementation, the prototype gradient is calculated separately for the observed category set, local category prototype, and effective global category prototype matching relationship of different clients, thereby forming a personalized gradient backpropagation.

[0015] In one implementation, the wireless edge learning system employs orthogonal frequency division multiple access uplink transmission. The uplink transmission latency of the client is determined by the uploaded payload and the achievable uplink rate. The uploaded payload is a prototype set consisting of local category prototypes and the number of category samples.

[0016] In one implementation, the method is used for multi-client collaborative training in image classification, mobile terminal perception, vehicle-to-everything (V2X) collaborative recognition, or industrial IoT fault diagnosis.

[0017] This invention relates to a split federated learning communication optimization system based on prototype learning, comprising a client module and a server module; the client module is used to generate split features, aggregate by category to obtain local category prototypes and the number of category samples, upload local category prototypes and the number of category samples, and update the client-side sub-model according to the prototype gradient returned by the server; the server module is used to calculate classification loss based on local category prototypes, maintain and update global category prototypes, calculate prototype alignment loss, update the server-side sub-model, and return prototype gradients to the client.

[0018] The core idea of ​​this invention is to replace the uplink transmission object from "the segmented features of each sample" to "the local category prototype of each observed category" while maintaining the partitioning of the federated learning model and the end-to-end training dependency. The client first generates the segmented features, then calculates the mean according to the sample category to obtain the local category prototype; the server treats these prototypes as input to the server-side sub-model, calculates the classification loss and prototype alignment loss, and maintains the global category prototype; the server calculates the gradient of the prototype and returns it to the client, enabling the client to continue backpropagation through the mean aggregation relationship. Beneficial effects

[0019] (1) The uplink load is significantly reduced. Traditional split federated learning uploads the hierarchical features of each sample, while the present invention uploads the prototype vector and the number of samples of each observed category in the current mini-batch. The communication load is mainly related to the number of categories and the prototype dimension.

[0020] (2) Preserve category semantic information. The category prototype is the semantic center of the representation of samples of the same class, which can preserve classification information while compressing redundant sample-level representations.

[0021] (3) Enhance the robustness of heterogeneous data. By using the alignment loss between local and global class prototypes, the class representations of different clients are pulled toward a shared semantic space, which helps to mitigate the statistical bias caused by non-independent and identically distributed data.

[0022] (4) Preserve the split learning structure. The server is still responsible for training the server-side sub-model, and the client still updates the client-side sub-model through the gradients returned by the server. Therefore, this invention does not break the end-to-end training dependency of split learning.

[0023] (5) Suitable for wireless edge scenarios. In wireless networks with limited uplink, limited client computing power, and significant heterogeneous data distribution, this invention is particularly effective in reducing communication latency and training bandwidth consumption. Attached Figure Description

[0024] The invention will now be described in more detail with reference to embodiments and the accompanying drawings. Figure 1 This is a schematic diagram of a split federated learning system model in a wireless network, in which multiple clients collaborate with an edge server for training via wireless links. Figure 2 This is a schematic diagram of the ProtoSFL method flow of the present invention, showing model broadcasting, local prototype calculation, prototype upload, server-side loss calculation, global prototype aggregation, and personalized prototype gradient backpropagation. Figure 3 For the Fashion-MNIST dataset in Dirichlet =0.1 and =0.3 Schematic diagram of the change of test accuracy with the number of communication rounds under two non-independent and identically distributed conditions; Figure 4 A diagram showing the comparison of the total uplink data volume for 100 training rounds of SplitFed, SD-SFL, and ProtoSFL under two Dirichlet settings. Detailed Implementation

[0025] The invention will now be further described with reference to the accompanying drawings.

[0026] like Figure 1 , Figure 2 As shown, in one embodiment, the wireless edge learning system includes K clients and one server. Each client k holds a private labeled dataset. It contains 1 labeled sample; among which, Indicates the input sample. These are category labels with values ​​ranging from 1 to C. Due to differences in user preferences, sensing environment, device status, and acquisition context, the local data distribution on each client can be non-independent and identically distributed.

[0027] The model to be trained is divided into client-side sub-models. and server-side sub-model ,in This represents the client-side sub-model with parameter φ. Indicates The server-side sub-model has parameters. The client-side sub-model is responsible for extracting early features from the original samples, while the server-side sub-model is responsible for subsequent classification or prediction. For client k, let its i-th sample be... The corresponding tag is Its conventional split federated learning local loss can be written as: (1) In equation (1), This represents the local training loss of client k. This represents the number of local samples for client k, where i represents the local sample index. This represents the cross-entropy loss. The global training objective is to minimize the weighted sum of the local losses across all clients: (2) (3) In equations (2) and (3), Let K represent the global training objective and K represent the total number of clients. Let represent the aggregate weight of client k, and j represent the client index used when summing the sample counts of all clients. Since The number of clients is normalized, therefore clients with a larger number of clients have a higher weight in the global objective. In the t-th communication round, the set of selected clients is denoted as... , where t represents the communication round index. The client-side and server-side parameters are initialized as follows: (4) (5) In equations (4) and (5), and Let $t$ represent the global client-side parameters and the global server-side parameters at the start of round $t$, respectively. and Let represent the initialization parameters of client k in the 0th local training step of round t. In local training step i, i = 1, 2, ..., I, where I represents the number of local training steps in each round, the parameters on the client side and the server side can be updated using gradient descent respectively. (6) (7) In equations (6) and (7), This represents the learning rate in round t. Represents the gradient operator. and These represent the client-side parameters and server-side parameters from the previous training step, respectively. After local split training is completed, the server performs weighted aggregation on the selected client models to obtain the global model parameters for the next communication round. (8) In equation (8), and These represent the global client-side parameters and global server-side parameters used in round t+1, respectively. This represents the set of clients selected in round t. and These represent the parameters of client k after completing I local training steps.

[0028] To characterize the communication benefits of this invention in wireless networks, a decomposition model of round-based latency in federated learning can be used. Let... and These represent the computational workload required by the client-side sub-model and the server-side sub-model to process one sample, respectively; the local mini-batch size is... The processor frequency of client k is The number of cores is calculated as follows: The floating-point operation capability per cycle is Then the client-side calculation latency is: (9) In equation (9), This indicates that client k calculates the latency on the client side in round t. Here... This represents the floating-point arithmetic capability of client k per cycle; it is a computational capability parameter and does not represent the client's local dataset. Assume the server processor frequency is... The number of cores is calculated as follows: The floating-point operation capability per cycle is Then the server-side computation latency is: (10) In equation (10), This represents the computational latency of the server processing the corresponding task in round t. In an orthogonal frequency division multiple access uplink system, if the bandwidth of each subchannel is W, and client k uses subchannel j in round t with a transmit power of W... Small-scale channel gain is The transmission distance is The path loss index is Noise power is Then its achievable uplink speed is: (11) In equation (11), Let represent the achievable rate of client k on channel j in round t. Here... This represents the wireless transmit power, distinct from p, which represents the category prototype later. If the client k's upload payload in this round is... Uplink speed is Then the uplink transmission delay is: (12) In equation (12), Let denot be the uplink transmission delay of client k in round t, and UL represent the uplink. The end-to-end delay of client k in round t can be expressed as: (13) In equation (13), This represents the round delay caused by the combined computation on the client side, computation on the server side, and uplink transmission. As can be seen from equation (12), when the uplink rate is constant, reducing the uplink load... This is a direct way to reduce training latency. Traditional split-feeded learning uploads high-dimensional segmented features sample by sample, leading to... Larger size; this invention significantly compresses the uploaded category prototype. .

[0029] Prototype learning aggregates the representations of samples of the same class in the embedding space into class centers. For input samples The embedded representation can be obtained through a client-side feature extractor and an optional projection head: (14) In equation (14), Indicates sample Embedded representation, This refers to the projection head with ψ as a parameter. Rᵈᵖ represents the embedding space dimension of the prototype. A real vector space. For class c, its prototype can be defined as the mean of the embeddings of all samples of that class: (15) (16) In equations (15) and (16), This represents the category prototype of category c. Represents the sample set, This represents the subset of samples labeled c. Let |·| represent the number of samples in that category, and |·| represent the number of elements in the set. For a query sample x, the posterior probability of the category can be calculated based on the distance between its embedding z and the prototypes of each category: (17) In equation (17), This represents the posterior probability that sample x belongs to class c. Let c' represent the distance function between the embedding representation and the category prototype, c' represent the category index in the denominator used to traverse all candidate categories, and exp represent the natural exponential function. In this invention, client k represents the current mini-batch. Perform client-side forward computation to obtain layered features. , for Vischer layering features. Indicates the current small batch The set of sample indices with label c. If category c appears in the current mini-batch, the local category prototype is calculated as follows: (18) In equation (18), This represents the local category prototype calculated by client k for category c. This represents the feature output of sample i from client k in the segmented layer. This represents the current set of mini-batch sample indices. This represents the set of sample indices belonging to category c. The client-uploaded object consists of the local prototype and the number of category samples corresponding to each observed category. equal The number of samples in This is the set of observed categories in the current mini-batch. This is a prototype vector, different from the transmit power in equation (11). For categories that do not appear, the corresponding prototype is not uploaded. Therefore, the uplink transmission volume of this invention is related to the number of observed categories, rather than being directly linearly related to the number of mini-batch samples.

[0030] The server has a server-side classifier and a global category prototype store. After receiving a local category prototype, the server uses it as input to calculate the classification loss. For client k, the classification loss weighted by the number of samples in each category is: (19) In equation (19), This represents the server-side classification loss corresponding to client k. This represents the set of observed categories in the current mini-batch for client k. This represents the number of samples of category c in the current mini-batch of client k. This indicates that the server-side submodel is related to the local category prototype. The prediction results are as follows. At the end of a training round, the server performs a weighted aggregation of prototypes of the same category uploaded by all selected clients. For category c, the aggregated prototype can be calculated as long as at least one client has uploaded a prototype of that category: (20) In equation (20), This represents the aggregate prototype of category c. The numerator represents the weighted sum of the local category prototypes of each selected client according to the number of samples in each category, and the denominator represents the total number of samples of category c in the selected clients. If the global category prototype of category c... If it has not been initialized, then the server will... Initialize the global category prototype; if it has already been initialized, a smooth update can be performed using momentum updates, for example: (twenty one) In equation (21), Represents the global category prototype of category c. This represents the momentum update coefficient, and The arrow indicates that the result on the right is used to update the global category prototype on the left. To mitigate the client-side semantic space offset caused by non-independent and identically distributed prototypes, this invention further introduces a local-global prototype alignment loss. If initialized, the prototype alignment loss of client k is: (twenty two) In equation (22), The prototype alignment loss of client k is represented by the L2 norm, which represents the Euclidean norm, and the local class prototype is represented by the L2 norm. Global category prototype of the same category The squared L2 distance between them represents the degree of semantic shift. The joint objective of the server on the client k is: (twenty three) In equation (23), The prototype alignment loss weights are defined as follows: the global category prototype represents the set of global prototypes maintained by the server, and min represents the weights for server-side parameters. And optimize the global category prototype set. The server updates the server-side sub-model according to formula (23) and optimizes the local category prototype. Calculate the gradient and return the gradient corresponding to the local class prototype to the client. This gradient represents the joint objective with respect to the local class prototype. The direction of change. Based on the mean aggregation relationship of equation (18), the client assigns the prototype gradient back to the slicing features of the corresponding sample and continues to backpropagate to update the client-side sub-model.

[0031] The complete training process of this invention can be described as follows: Step 1: Server initializes global model parameters , and initialize the global prototypes for each category. .

[0032] Step 2: In each communication round t, the server selects the client set. It also broadcasts the current model parameters and the global prototype.

[0033] Step 3: Each client receives parameters in parallel, initializes its local model as the current global model, and performs client-side forward computation on local mini-batch samples.

[0034] Step 4: The client calculates the average of the segmented features by category to obtain the local category prototype. and the number of samples by category And upload it to the server.

[0035] Step 5: The server calculates the classification loss L based on the local category prototype. 1,k Alignment loss L is calculated based on global category prototypes. 2,k and form a joint objective L k .

[0036] Step 6: The server updates the sub-model parameters on the server side, calculates the gradient of the local category prototype, and returns the personalized prototype gradient to the corresponding client.

[0037] Step 7: The client updates the parameters of the client-side sub-model by backpropagating through the prototype mean aggregation relationship.

[0038] Step 8: At the end of each round, the server aggregates the model parameters from the client side and the server side, updates the global category prototype in a weighted manner, and enters the next round of training.

[0039] Suppose that in traditional split federated learning, each sample needs to be uploaded in a certain dimension. If the number of locally processed samples is N, then the upload complexity is approximately [missing information]. ,in This represents a complexity metric. In this invention, each participating client only uploads prototypes of the observed categories. If the number of participating clients is K, the number of categories is C, and the prototype dimension is... The overall upload complexity is approximately Therefore, we have: (twenty four) In equation (24), the left side represents the upload complexity of this invention measured by client, category, and prototype dimensions, and the right side represents the upload complexity of traditional sample-level segmentation features. This indicates that the complexity on the left is significantly less than that on the right. This difference is even more pronounced when the number of samples in a mini-batch is large, the feature map dimension is high, or the data distribution is skewed, resulting in fewer categories in each mini-batch. In strongly non-independent and identically distributed scenarios, each mini-batch on the client side typically contains only a few categories, further reducing the number of uploaded prototypes in this invention, thus making the communication benefits more significant.

[0040] In one simulation implementation, the Fashion-MNIST dataset was used for validation. This dataset includes 60,000 training images and 10,000 test images, divided into 10 categories. The training data was distributed to 100 clients according to a Dirichlet distribution with non-independent and identically distributed parameters. Take 0.1 or 0.3, where A smaller value indicates a greater degree of data heterogeneity. In each communication round, 10 clients are randomly selected evenly to participate in training. All methods use the same data partitioning, user selection plan, model initialization, and mini-batch size. The total number of training rounds is 100, and the mini-batch size is 32.

[0041] The comparison methods include SplitFed and SD-SFL. SplitFed is a conventional split federated learning baseline that uploads complete per-sample split features; SD-SFL is a spatial downsampling baseline that reduces some uplink overhead by uploading downsampled split features, but still retains the sample-level transmission mechanism.

[0042] like Figure 3 As shown, in Strongly heterogeneous scenarios with a value of 0.1 and In a relatively weakly heterogeneous scenario with a coefficient of 0.3, all methods gradually converge with increasing communication rounds. Because... =0.1 corresponds to stronger label skewness, and the final test accuracy of all methods is usually lower than 0.1. The result is 0.3. While maintaining similar accuracy to SplitFed and SD-SFL, ProtoSFL converges faster in the early rounds, indicating that the category prototype can aggregate similar samples into stable semantic centers, which helps the model learn basic category differences more quickly.

[0043] like Figure 4 As shown, ProtoSFL achieves the lowest uplink throughput under both heterogeneity levels. When When the upload speed is 0.1, the total upload size of SplitFed, SD-SFL, and ProtoSFL is approximately 29.32 GB, 7.33 GB, and 2.99 GB, respectively, with ProtoSFL reducing upload size by approximately 89.81% compared to SplitFed. At a resolution of 0.3, ProtoSFL still maintains the minimum upload volume, reducing it by approximately 81.79% compared to SplitFed. This demonstrates that the prototype-based transport mechanism can significantly reduce communication overhead while preserving necessary category semantic information, and its advantages are even more pronounced in scenarios with more skewed data and fewer observed categories per mini-batch.

[0044] In one alternative implementation, the client can set the projection head after slicing the layers. The layered features are mapped to a low-dimensional prototype space to further reduce the prototype dimensionality. .

[0045] In one alternative implementation, the prototype distance metric Euclidean distance, cosine distance, Mahalanobis distance, or other differentiable distance functions can be selected.

[0046] In one alternative implementation, the global category prototype may be updated using direct weighted replacement, momentum update, exponential moving average, or adaptive update with confidence.

[0047] In one alternative implementation, the local category prototype may be further quantized, sparsified, pruned, or entropy encoded before uploading.

[0048] In one alternative implementation, the server may select participating clients based on wireless channel status, client computing power, historical participation frequency, or category coverage.

[0049] In one alternative implementation, the present invention can be used not only for image classification, but also for multi-client collaborative tasks such as speech recognition, behavior recognition, vehicle networking perception, industrial equipment status recognition, and medical edge intelligent diagnosis.

[0050] This invention proposes a prototype-based split federated learning communication optimization method. Without directly uploading the original data, it replaces the uplink transmission object in split federated learning with per-sample high-dimensional segmentation features, using category-level local prototypes and sample counts. Furthermore, it introduces classification loss and local-global prototype alignment loss for joint training on the server side. This method can significantly reduce uplink traffic in wireless networks while maintaining the accuracy of competitive models, making it particularly suitable for wireless edge learning scenarios with limited uplink capacity and highly non-independent and identically distributed client data.

[0051] The above embodiments are only used to illustrate the technical solutions of the present invention, and are not intended to limit the scope of protection. Any equivalent substitutions or improvements made to the model structure, prototype dimension, distance function, aggregation weight, client selection strategy, wireless resource allocation method, etc., within the spirit and principles of the present invention, should be included within the scope of protection of the present invention.

Claims

1. A method for optimizing communication in split-fed learning based on prototype learning, characterized in that, A method for a wireless edge learning system comprising multiple clients and a server includes: the server sending client-side sub-model parameters and server-side sub-model parameters obtained from the global model partitioning to selected clients; the clients using the client-side sub-model performing forward computation on local mini-batch samples to obtain stratified features; the clients aggregating the stratified features according to sample categories to obtain local category prototypes and the number of category samples corresponding to each observed category; the clients uploading the local category prototypes and the number of category samples to the server; the server calculating a classification loss based on the local category prototypes, performing weighted aggregation of local category prototypes of the same category uploaded by multiple clients based on the number of category samples to update the global category prototype, and calculating a prototype alignment loss between the local category prototypes and the corresponding global category prototypes; the server constructing a joint training objective based on the classification loss and the prototype alignment loss, updating the server-side sub-model, and returning the prototype gradients corresponding to the observed categories of each client to the corresponding clients; the clients backpropagating based on the prototype gradients via prototype aggregation relationships to update the client-side sub-model.

2. The method according to claim 1, characterized in that, The local category prototype is the mean vector of the stratified features corresponding to the same category in the current mini-batch samples.

3. The method according to claim 1, characterized in that, The client only uploads the local category prototype and the number of category samples corresponding to the categories that actually appear in the current mini-batch, so that the uplink transmission volume changes with the number of observed categories, rather than increasing linearly with the total number of mini-batch samples.

4. The method according to claim 1, characterized in that, The classification loss is the cross-entropy loss obtained by the server-side classifier after predicting the category of the local category prototype, and is weighted averaged according to the number of samples in each category.

5. The method according to claim 1, characterized in that, The prototype alignment loss is the distance loss between the local category prototype and the global category prototype of the same category, and the distance loss includes the squared Euclidean distance loss.

6. The method according to claim 1, characterized in that, The joint training objective is a weighted sum of the classification loss and the prototype alignment loss.

7. The method according to claim 1, characterized in that, The prototype gradient is calculated separately for the observed category set, local category prototype, and effective global category prototype matching relationship of different clients, thereby forming a personalized gradient backhaul.

8. The method according to claim 1, characterized in that, The wireless edge learning system uses orthogonal frequency division multiple access uplink transmission. The uplink transmission latency of the client is determined by the uploaded payload and the achievable uplink rate. The uploaded payload is a prototype set consisting of local category prototypes and the number of category samples.

9. The method according to claim 1, characterized in that, The method is used for multi-client collaborative training in image classification, mobile terminal perception, vehicle-to-everything (V2X) collaborative recognition, or industrial IoT fault diagnosis.

10. A split-federated learning communication optimization system based on prototype learning, characterized in that, It includes a client module and a server module; the client module is used to generate segmented features, aggregate by category to obtain local category prototypes and the number of category samples, upload local category prototypes and the number of category samples, and update the client-side sub-model according to the prototype gradient returned by the server; the server module is used to calculate the classification loss based on the local category prototype, maintain and update the global category prototype, calculate the prototype alignment loss, update the server-side sub-model, and return the prototype gradient to the client.

Images