An unmanned aerial vehicle federal fault diagnosis method fusing parameter coordination and collaborative aggregation

Abstract

The application relates to the technical field of unmanned aerial vehicle fault diagnosis, in particular to a unmanned aerial vehicle federal fault diagnosis method fusing parameter coordination and collaborative aggregation, which decouples a global fault diagnosis model into a feature extractor containing shared parameters and a classifier containing individualized parameters, a client completes local training by screening and coordinating parameters based on parameter update consistency by constraining parameter deviation; a server allocates initial aggregation weights based on a Fisher information matrix, and constructs a global consensus area to optimize weights and complete collaborative aggregation; the application aims to solve the problems that in the unmanned aerial vehicle fault diagnosis scene, a centralized method is difficult to meet the data privacy protection requirement, traditional federal learning causes parameter update conflicts and model performance degradation due to client data heterogeneity, and low participation of clients under the limitation of unmanned aerial vehicle communication weakens the global collaborative training effect, and further leads to the problems of insufficient fault diagnosis accuracy, robustness and generalization.

Description

Technical Field

[0001] This invention relates to the field of unmanned aerial vehicle (UAV) fault diagnosis technology, and in particular to a UAV federal fault diagnosis method that integrates parameter coordination and collaborative aggregation. Background Technology

[0002] With the rapid development of the low-altitude economy, unmanned aerial vehicles (UAVs) have achieved large-scale application in many fields such as agricultural plant protection, air logistics, emergency rescue, and geographic surveying due to their advantages of high mobility, flexible deployment, and controllable cost. However, UAV systems are complex in structure, operate under variable flight conditions, and face complex operating environments. Their core components, such as power systems, onboard sensors, and flight control modules, are prone to anomalies and malfunctions. These malfunctions can not only interrupt flight missions but also lead to serious safety accidents and economic losses, such as crashes and third-party damage. Therefore, high-precision and high-reliability UAV fault diagnosis technology is a key technology for ensuring safe UAV flight and promoting the high-quality development of the low-altitude economy. Traditional data-driven fault diagnosis methods require centralized collection and training of multi-source UAV data. However, UAV flight data contains a large amount of operational privacy, geographically sensitive information, and core flight control data. Centralized processing poses a serious risk of privacy leakage. Federated learning, as a distributed machine learning framework, can achieve multi-node collaborative training of a global model without requiring the original data to leave the local machine. This allows for joint optimization of the fault diagnosis model while ensuring data privacy and security, and has become the mainstream research and application direction in the field of UAV fault diagnosis.

[0003] In real-world drone swarm operations, federated learning-based fault diagnosis methods face two major technical bottlenecks that are difficult to address simultaneously. The first is the problem of data heterogeneity. Different drones exhibit significant differences in hardware configuration, load status, and flight conditions. Under different flight states such as acceleration, deceleration, hovering, constant speed, and circling, the distribution of operational data features and fault characterization patterns collected by airborne sensors show marked differences. This results in heterogeneous local data from each drone client, which is not independently distributed. Traditional federated learning methods in this scenario are prone to feature space shifts and inconsistent classification decision boundaries, causing a sharp decline in the fault diagnosis accuracy and generalization ability of the global model. Secondly, there is the problem of communication limitations. Drone swarms mostly use wireless communication for data interaction, which has inherent defects such as limited communication bandwidth, poor connection stability, and susceptibility to flight environment and electromagnetic interference. It cannot support high-frequency, full-parameter model interaction of all drone clients. In actual training, only a small number of clients can be selected to participate in each round of global iteration. The local model training of clients with low participation is insufficient, and their parameter updates can easily cause negative interference to global model aggregation. At the same time, the traditional full-parameter aggregation method also brings excessive communication overhead and is difficult to adapt to the communication environment constraints of actual drone operations.

[0004] To address the aforementioned issues, researchers both domestically and internationally have conducted numerous related studies. Among them is an invention patent with publication number CN120217116A entitled "A Cross-Condition Fault Diagnosis Method for UAVs Based on Double-Aligned Federated Metric Learning." This solution targets heterogeneous UAV scenarios across different operating conditions. Through a double-alignment mechanism of feature alignment and classifier alignment, combined with a metric learning strategy for clustering anchor points, it brings similar fault features closer together and pushes dissimilar fault features further apart. This unifies the feature space and classification decision boundary of different clients, alleviating to some extent the model performance degradation problem caused by heterogeneous cross-condition data. At the same time, by uploading only model parameters and feature anchor points, it achieves privacy protection by ensuring that the original data does not leave the local machine. However, this scheme has three major flaws: First, it uses a simple equal-weight average aggregation method, failing to consider the negative impact of insufficient training by low-participation clients in communication-constrained scenarios on the global model. When client participation falls below 50%, the model's diagnostic accuracy drops drastically. Second, it fails to screen and coordinate parameter-level update conflicts, unable to resolve model oscillations caused by opposing parameter update directions from different clients in heterogeneous data scenarios. Third, it fails to decouple model parameters from individual settings, making it prone to disrupting the classification boundaries of client-local adaptation to heterogeneous data after global model distribution. In scenarios with high client data heterogeneity, the model's convergence stability and diagnostic accuracy are significantly limited. Furthermore, among mainstream federated learning optimization methods, FedAvg... The average aggregation strategy with equal weights is simple in computation and has a low deployment threshold, but it is extremely sensitive to data heterogeneity and is prone to model divergence in non-independent and identically distributed scenarios. FedProx alleviates model fluctuations caused by data heterogeneity by introducing proximal terms to constrain the update deviation between local and global parameters, but it does not solve the parameter interference problem of low-quality clients from the perspective of aggregation weight optimization. FedDyn, FedProto and other methods optimize the model's heterogeneous data adaptability through dynamic regularization, prototype alignment and other methods, but none of them can simultaneously take into account the dual constraints of data heterogeneity and communication limitations in UAV scenarios. They cannot simultaneously ensure the model's fault diagnosis accuracy, convergence efficiency and lightweight communication in actual working conditions with low client participation and high data heterogeneity. Based on this, this invention addresses the core pain points of heterogeneous data and limited communication in UAV fault diagnosis scenarios by proposing a UAV federated fault diagnosis method that integrates parameter coordination and collaborative aggregation. Through a parameter coordination mechanism of parameter decoupling training and update consistency screening, combined with a collaborative aggregation strategy of Fisher information matrix weight quantization and parameter consensus region optimization, this method simultaneously solves the problems of parameter update conflicts under heterogeneous data and low-quality client interference under limited communication, thereby achieving high-precision, high-robustness, and low-communication-overhead UAV federated fault diagnosis. Summary of the Invention

[0005] This invention provides a method for fault diagnosis of UAV federation that integrates parameter coordination and collaborative aggregation, in order to solve the problems of parameter update conflicts and model performance degradation caused by heterogeneous client data in traditional federated learning, as well as the weakening of global collaborative training effect by low-participation clients due to limited UAV communication, which in turn leads to insufficient fault diagnosis accuracy, robustness and generalization.

[0006] To solve the above problems, the technical solution adopted by the invention is as follows:

[0007] A federated fault diagnosis method for unmanned aerial vehicles (UAVs) that integrates parameter coordination and collaborative aggregation is applied to a federated learning system comprising a central server and N UAV clients. Each UAV client locally stores an independent time-series dataset of UAV flight sensors and corresponding fault labels. All clients share the same fault label space, and the data among clients are heterogeneously distributed. The method includes the following steps:

[0008] S1: System initialization. The central server builds and initializes a global fault diagnosis model, decoupling the global fault diagnosis model into a feature extractor containing shared parameters and a classifier containing personalized parameters. The central server encrypts and distributes the initialized global model to each UAV client. Each UAV client preprocesses its local dataset to obtain model input samples.

[0009] S2: Client-side local federated parameter coordination training. After receiving the global model, each participating drone client performs multiple rounds of local training on the local dataset. During the training process, the deviation between shared parameters and personalized parameters is first constrained, and then the parameter update consistency PUC value of each shared parameter is calculated. Based on the PUC value, the coordinated parameters are selected and the local model parameter update is completed.

[0010] S3: Client information upload. Each drone client that has completed local training calculates the Experience Fisher Information Matrix (FIM) of its local model, extracts the trace of the FIM as the local information entropy metric, and simultaneously uploads the locally updated shared parameters, coordination parameter selector, and information entropy metric to the central server in encryption.

[0011] S4: Server-side federated collaborative aggregation. After receiving information uploaded by each client, the central server first normalizes the information entropy metric of each client to obtain the initial aggregation weight of each client. Then, it constructs a global consensus region based on the coordination parameter selector of each client. Within the consensus region, gradient descent is used to optimize and obtain personalized aggregation weights with the goal of minimizing the parameter differences between the local model of each client and the global model within the consensus region. Finally, the aggregation update of the global model is completed based on the optimized aggregation weights.

[0012] S5: Iterative training and fault diagnosis. The central server distributes the updated shared parameters of the global model to each UAV client, repeating steps S2 to S4 until the preset global training rounds or model convergence threshold are reached to obtain the final fault diagnosis model. The UAV client collects real-time flight sensor data, inputs it into the fault diagnosis model, and outputs the UAV fault diagnosis result.

[0013] The principle and advantages of this scheme are as follows:

[0014] The principle of this solution is that during the system initialization phase, the global fault diagnosis model is decoupled into a feature extractor with shared parameters and a classifier with personalized parameters. At the architectural level, this balances the core advantages of federated learning's global knowledge collaboration with the client's personalized needs for adapting to heterogeneous data. Simultaneously, local data preprocessing is completed through standardization and sliding window data augmentation, ensuring the consistency of model input and training stability. During the client-side local training phase, the deviation between shared and personalized parameters is constrained, integrating local feature knowledge into the global shared parameters to resolve the mismatch between global parameter updates and local personalized parameters. Then, by calculating the parameter update consistency (PUC) value, coordinated parameters with consistent update directions from multiple rounds are selected. Only these coordinated parameters participate in local model updates, fundamentally filtering out invalid parameters caused by conflicting update directions due to heterogeneous data, preventing important parameter updates from being overwhelmed by irrelevant parameters. No, it achieves coordinated and unified local parameter updates; in the server aggregation stage, the trace quantification of each client model is first used to determine the information content and training adequacy of each client model. Based on this, the initial aggregation weights are allocated, which reduces the adverse effects of low participation and insufficient training clients on the global model in communication-constrained scenarios from the weight allocation level. Then, a global consensus region is constructed based on the coordinated parameter selectors of each client. The aggregation weights are optimized only in the parameter region where most clients reach an update consensus, further unifying the optimization direction of global aggregation, reducing aggregation bias caused by heterogeneous data, and completing the collaborative optimization of the global model. Finally, through multiple rounds of iterative client-server collaborative training, a UAV fault diagnosis model that balances privacy protection, heterogeneous data adaptability, and robustness in communication-constrained scenarios is obtained, which can be directly deployed on UAV clients to achieve local real-time fault diagnosis.

[0015] Compared to existing technologies, this solution addresses the parameter update conflict problem in heterogeneous data scenarios. It breaks away from the conventional approach of simply separating shared and personalized parameters in existing personalized federated learning, pioneering a federated parameter coordination mechanism of "bias constraint - coordinated parameter selection." Compared to traditional methods like FedAvg and FedProx, which only mitigate the impact of heterogeneity through weighted averaging or regularization constraints, this solution eliminates update conflicts caused by heterogeneous data at their root. In heterogeneous data scenarios with varying degrees of UAV faults, it achieves an average fault diagnosis accuracy improvement of 2.66%, particularly in feature differentiation such as hovering. In low-intensity, highly heterogeneous operating conditions, the accuracy improvement reached 3.66%, addressing the industry pain point of significantly reduced fault detection capability under stable flight conditions in existing technologies. Secondly, addressing the issue of low-participation clients weakening the overall training effect due to limited UAV communication, this solution constructs a collaborative aggregation mechanism of "FIM initial weighting - consensus region optimization." This breaks through the inherent mode of data-volume-weighted aggregation in existing technologies, achieving adaptive tilting of aggregation weights towards well-trained, active clients. Simultaneously, the global consensus region further unifies the aggregation optimization direction, compared to existing technologies... To overcome the performance degradation inherent in traditional methods when client engagement decreases, this solution maintains an average fault diagnosis accuracy of 81.73% even in extremely communication-constrained scenarios with only 20% client engagement. This represents a 19.12 percentage point improvement over the traditional FedAvg's 62.61%. Furthermore, when client engagement drops from 80% to 20%, the model accuracy decreases by only 4.04%, significantly lower than FedAvg's 17.6 percentage point decrease. This demonstrates exceptionally high model performance stability in communication-constrained scenarios, an unexpected and remarkable achievement unattainable by existing technologies. Thirdly, this solution... The method completes collaborative training of models without disclosing the original local flight data of the UAV, balancing the dual requirements of UAV data privacy protection and fault diagnosis performance. Compared with centralized fault diagnosis methods, it completely avoids the privacy leakage risk caused by uploading sensitive flight data. At the same time, compared with existing federated learning methods, it can still maintain high accuracy, strong robustness and good generalization in the dual extreme scenarios of heterogeneous data and limited communication. It is perfectly adapted to the complex working conditions and strict privacy and communication constraints of real UAV flight scenarios in the low-altitude economy, and provides reliable fault diagnosis technology support for UAV flight safety.

[0016] Furthermore, the constraint on the deviation between the shared parameters and the personalized parameters in step S2 specifically includes: for the t-th round of global training, the drone client utilizes the globally shared parameters from the (t-1)-th round. In local dataset Generate feature embeddings The feature embedding The expression is: In the formula, This represents the feature extraction mapping function of the feature extractor. Indicates the dimension of feature embedding. Indicates an active client Local dataset The number of samples, For the local dataset of the i-th client, For the (t-1)th round globally shared parameters received by the i-th client; construct the mean squared error loss function to constrain the t-th round globally shared parameters. Output and Feature Embedding The deviation is expressed by the loss function as follows: The globally shared parameters are updated using gradient descent based on the loss function. This approach enables shared parameters to learn local feature embedding knowledge and maintain coordination with personalized parameters. By constraining the deviation between shared and personalized parameters during local training, the global shared parameters can continuously absorb feature knowledge from the client's local data during iterative updates, maintaining alignment with the output of the local personalized classifier. This avoids the problem of mismatch between shared and personalized parameters and inconsistent model output caused by direct overwriting of global parameters. At the same time, it can effectively reduce the offset between local and global models caused by data heterogeneity, improve the stability of local training, and make subsequent parameter selection and global aggregation smoother, ultimately significantly improving the adaptability and accuracy of the fault diagnosis model.

[0017] Furthermore, step S2, which calculates the parameter update consistency (PUC) value for each shared parameter, filters coordinated parameters based on the PUC value, and completes the local model parameter update, specifically includes: for the m-th shared parameter of the i-th client in the t-th round of global training. Calculate the consistency of its update directions across multiple rounds to obtain the corresponding PUC value. The calculation formula is: , This is an indicator function used to determine whether the change direction of locally shared parameters is a positive increment. The size of the sliding window used to record the update direction. This is the starting position of the sliding window; Let m be the update amount of the m-th shared parameter of the i-th client in round t. The preset starting position for the sliding window. threshold A coordination parameter selector is constructed based on the PUC value. The expression is

[0018] The update of locally shared parameters is performed based on the coordination parameter selector, and the update formula is as follows: ,in For the shared parameters updated by the i-th client, Let M be the number of shared parameters before the i-th client update. By calculating the parameter update consistency (PUC) value and selecting coordinated parameters based on this value, only highly consistent parameters are retained to participate in local model updates. This can accurately identify and retain parameters with stable update directions and substantial contributions to model optimization in multiple iterations. It can proactively discard invalid parameters that cause update direction conflicts due to heterogeneous client data and are prone to model degradation. This fundamentally alleviates the parameter update disorder caused by data heterogeneity, prevents important parameter updates from being overwhelmed by interfering parameters, and makes local model updates more focused on effective information. This improves model convergence stability and fault diagnosis accuracy, provides high-quality and highly consistent local parameters for subsequent server-side collaborative aggregation, and ensures the effectiveness of global model collaborative training.

[0019] Furthermore, step S3, which involves calculating the Fisher Information Matrix (FIM) of the local model and extracting the trace of the FIM as a measure of local information entropy, specifically includes: calculating the multi-class log-likelihood function based on the softmax output of the i-th client-side local model. The expression is: ,in, For the local model parameters of the i-th client, For local datasets In model parameters The probability density function is given below; the empirical Fisher information matrix (FIM) is calculated based on the gradient of the log-likelihood function, using the following formula: in, The log-likelihood function is relative to the model parameters. gradient, superscript This is a matrix transpose operation; the trace of the FIM matrix is ​​extracted as a local information entropy metric. The calculation formula is: ,in, The total dimension of the model parameters. The j-th element on the diagonal of the FIM matrix is ​​used to calculate the Fisher Information Matrix (FIM) and use its trace as a measure of local information entropy. This method can objectively quantify the effective information learned by each client model on local data and the degree of training sufficiency. It can accurately identify low-quality client updates with low participation and insufficient training in communication-constrained scenarios, avoid the global model offset problem caused by traditional data-weighted aggregation, automatically reduce the weight influence of weakly contributing clients and strengthen the parameter contributions of high-information-content clients during aggregation, significantly improve the reliability and stability of global model aggregation, and provide an objective weight basis for subsequent consensus region optimization. This allows the global model to maintain efficient convergence and high diagnostic accuracy under the dual challenges of communication constraints and data heterogeneity.

[0020] Furthermore, in step S4, the initial aggregation weight of each client is obtained by normalizing the information entropy metric value of each client. This specifically includes: normalizing the information entropy metric value of each client. Normalization is performed to obtain the initial aggregate weights for the i-th client. The calculation formula is: Where N is the total number of drone clients participating in this round of training; the initial aggregation update of shared parameters is completed based on the initial aggregation weights, and the formula is: in, These are the globally shared parameters after initial aggregation. These are the globally shared parameters used at the beginning of this training round. For the shared parameters updated locally by the i-th client, the initial aggregation weight is obtained by normalizing the information entropy metric of each client, and the initial aggregation update of the shared parameters is completed based on this weight. The aggregation weight can be dynamically allocated based on the actual effective information of the client, replacing the traditional weighting method based on data volume. This effectively suppresses the negative interference of low-participation and insufficiently trained clients on the global model under communication constraints, making the global shared parameter update more in line with the effective information of high-contribution clients, improving the rationality and stability of global model aggregation, and laying a reliable foundation for the personalized weight optimization in the subsequent consensus region. This ensures that the global model can still converge stably and maintain high fault diagnosis accuracy in heterogeneous data and weak communication environments.

[0021] Furthermore, in step S4, constructing a global consensus region based on the coordination parameter selector of each client specifically includes: for the m-th shared parameter, calculating the proportion of all clients that determine it as a coordination parameter. The calculation formula is: ,in, For indicator functions, The total number of drone clients participating in this round of training. For the i-th client, a coordinating parameter selector for the m-th shared parameter; a preset consensus threshold. Construct a global consensus mask The consensus parameter is identified by the following expression: ,all The corresponding shared parameters constitute a global consensus region. The optimization of aggregation weights and the final aggregation of the global model are only performed within the global consensus region. By constructing a global consensus region based on the parameter selector coordinated by each client, shared parameters that have consistent update directions among most clients and have global collaborative value can be accurately selected. Unstable parameters that are only recognized by a few clients and are prone to aggregation conflicts are excluded. From the aggregation scope, aggregation bias caused by data heterogeneity and low participation is further avoided. The global model completes its final optimization only within the highly collaborative consensus parameter range, which significantly improves the consistency and robustness of model aggregation. At the same time, it reduces the computation and communication overhead caused by invalid parameters, enabling the model to maintain efficient convergence and stable fault diagnosis performance even in complex UAV operating conditions and communication-limited scenarios.

[0022] Further, in step S1, the feature extractor of the global fault diagnosis model consists of multiple one-dimensional convolutional layers, ReLU activation layers, and pooling layers, used to extract fault feature vectors from the UAV flight sensor time-series data; the classifier is a linear mapping layer, whose input dimension is consistent with the output dimension of the feature extractor, used to output fault category prediction results based on the fault feature vectors output by the feature extractor; the input of the model is the preprocessed UAV flight sensor time-series data x. Where T is the time step and C is the number of sensor channels; the mapping relationship of the feature extractor is as follows: , ,in Let d be the extracted fault feature vector, and d be the dimension of the fault feature vector; the mapping relationship of the classifier is as follows: ,in For fault diagnosis results, For the fault label space, the global fault diagnosis model is designed as a decoupled form of a one-dimensional convolutional feature extractor and a linear mapping classifier. This can efficiently adapt to the feature extraction requirements of UAV flight sensor time-series data. It uses one-dimensional convolutional layers, ReLU activation layers and pooling layers to accurately capture fault features in flight time-series signals, balancing feature extraction efficiency and nonlinear expression capabilities. At the same time, the decoupled architecture separates shared feature knowledge from local personalized classification, ensuring both collaborative training and knowledge sharing of the global model in federated learning, and meeting the personalized adaptation requirements of each client for local heterogeneous data. This allows the model to have both strong feature extraction capabilities and high fault classification accuracy under the premise of privacy protection, adapting to fault diagnosis scenarios of UAVs with multiple operating conditions and heterogeneous data.

[0023] Furthermore, in step S1, the local datasets of each client undergo standardization and sliding window data augmentation preprocessing, specifically including: using the Z-score standardization method to standardize the original feature vectors, eliminating differences in feature dimensions. The standardization formula is: ,in, Let j be the j-th dimension feature of the i-th sample in the original feature matrix. Let be the mean of the j-th feature across all samples. Let be the standard deviation of the j-th feature across all samples. Sliding window data augmentation is applied to the standardized data, with a sliding window size of 128 and a step size of 16. The resulting sample dimension is 12×128, where 12 represents the number of sensor feature channels, corresponding to the velocity, acceleration, angular velocity, and Euler angles in the x, y, and z directions of the UAV. Z-score standardization eliminates the dimensional and numerical differences among sensor features, unifying the input distribution, accelerating gradient descent convergence, and reducing training bias. Combined with sliding window augmentation of size 128 and step size 16, the multi-dimensional time-series signals of the UAV can be transformed into stable 12×128 input samples, fully preserving the temporal correlation features of the flight state and expanding the effective sample size. This allows the model to learn key fault information such as velocity, acceleration, angular velocity, and Euler angles more stably, significantly improving the convergence efficiency of federated training and the accuracy and robustness of fault diagnosis.

[0024] Furthermore, during the training process from steps S2 to S4, for scenarios where UAV communication is limited, active UAV clients are randomly selected in each round of global training to perform local training and information uploading according to a preset client participation ratio. Inactive clients do not participate in the training and global aggregation of this round. The client participation ratio ranges from 20% to 80%. In the training process from steps S2 to S4, active clients are randomly selected to participate in the training and aggregation of this round according to a preset ratio of 20% to 80%. This can closely match the limited scenarios in actual UAV flight, such as limited communication bandwidth, unstable signals, and temporary offline status of some nodes. This avoids communication congestion, excessive energy consumption, and training delays caused by the forced participation of all clients. It can also effectively avoid interference from low-participation and insufficiently trained clients on the global model update through dynamic screening. At the same time, it ensures that there are still a sufficient number of high-quality nodes participating in each round of aggregation, so that the global model can still converge stably and continuously optimize under communication-limited conditions. This greatly improves the environmental adaptability, training reliability, and engineering practicality of the entire federated fault diagnosis system.

[0025] Furthermore, in step S4, the optimization objective of optimizing the personalized aggregation weights within the consensus region is to minimize the parameter differences between the local models of each client and the global model within the consensus region. Gradient descent is used for iterative optimization until the weight change is less than a preset threshold. Based on the optimized personalized aggregation weights, the final aggregation update of the global shared parameters is completed. The updated shared parameters of the global model are only distributed to the feature extractor modules of each drone client. The classifier module is independently trained and updated locally by each drone client. The personalized aggregation weights are optimized with the goal of minimizing the parameter differences between the local models of the clients and the global model within the consensus region. This approach further reduces the distribution deviation between the local and global models, allowing the globally shared parameters to better align with the optimal update direction for multi-client collaboration. Simultaneously, the updated global model is only distributed to the feature extractor module, while the classifier is independently trained and updated locally on the client. This preserves the privacy and knowledge-sharing advantages of federated learning while fully adapting to the heterogeneous data characteristics of each client. It significantly improves the personalized diagnostic accuracy of the model under different UAV fault conditions, reduces communication transmission volume, and lowers the computational and communication energy consumption of the UAV. This enables the entire system to achieve high accuracy, strong robustness, and high execution efficiency even in scenarios with heterogeneous data and limited communication. Attached Figure Description

[0026] Figure 1 This is a schematic diagram of the federated learning framework process of the present invention;

[0027] Figure 2 This is a deployment architecture diagram of the unmanned aerial vehicle (UAV) fault diagnosis federated learning system of the present invention.

[0028] Figure 3 This is a schematic diagram of parameter decoupling in the personalized federated learning model of the present invention.

[0029] Figure 4 This is a comparison chart of the Z-score normalization processing effect of the UAV runtime sequence data of the present invention.

[0030] Figure 5 This is a radar comparison chart of the fault diagnosis performance of different federated learning methods in heterogeneous scenarios with multiple flight conditions.

[0031] Figure 6 This is a comparison chart of the confusion matrix of UAV fault diagnosis under accelerated operating conditions using different federated learning methods.

[0032] Figure 7 This is a comparison chart of the confusion matrix of UAV fault diagnosis under different federated learning methods under deceleration conditions.

[0033] Figure 8 This is a comparison chart of the confusion matrix of UAV fault diagnosis using different federated learning methods under hovering conditions.

[0034] Figure 9 This is a comparison chart of the confusion matrix of UAV fault diagnosis using different federated learning methods under uniform operating conditions.

[0035] Figure 10 This is a comparison chart of the confusion matrix of UAV fault diagnosis using different federated learning methods under hovering conditions.

[0036] Figure 11 This is a visualization of the fault diagnosis accuracy results of different FedPHSA variants under various flight conditions.

[0037] Figure 12 This is a visualization of the fault diagnosis accuracy results of different FedPHSA variants under different client engagement levels. Detailed Implementation

[0038] Example 1

[0039] like Figure 1-12 As shown, a federated fault diagnosis method for unmanned aerial vehicles (UAVs) that integrates parameter coordination and collaborative aggregation is applied to a federated learning system containing a central server and N UAV clients. Each UAV client locally stores an independent UAV flight sensor time-series dataset and corresponding fault labels. All clients share the same fault label space, and the data among clients are heterogeneously distributed. The method includes the following steps:

[0040] S1: System initialization. The central server builds and initializes a global fault diagnosis model, decoupling the global fault diagnosis model into a feature extractor containing shared parameters and a classifier containing personalized parameters. The central server encrypts and distributes the initialized global model to each UAV client. Each UAV client preprocesses its local dataset to obtain model input samples.

[0041] S2: Client-side local federated parameter coordination training. After receiving the global model, each participating drone client performs multiple rounds of local training on the local dataset. During the training process, the deviation between shared parameters and personalized parameters is first constrained, and then the parameter update consistency PUC value of each shared parameter is calculated. Based on the PUC value, the coordinated parameters are selected and the local model parameter update is completed.

[0042] S3: Client information upload. Each drone client that has completed local training calculates the Experience Fisher Information Matrix (FIM) of its local model, extracts the trace of the FIM as the local information entropy metric, and simultaneously uploads the locally updated shared parameters, coordination parameter selector, and information entropy metric to the central server in encryption.

[0043] S4: Server-side federated collaborative aggregation. After receiving information uploaded by each client, the central server first normalizes the information entropy metric of each client to obtain the initial aggregation weight of each client. Then, it constructs a global consensus region based on the coordination parameter selector of each client. Within the consensus region, gradient descent is used to optimize and obtain personalized aggregation weights with the goal of minimizing the parameter differences between the local model of each client and the global model within the consensus region. Finally, the aggregation update of the global model is completed based on the optimized aggregation weights.

[0044] S5: Iterative training and fault diagnosis. The central server distributes the updated shared parameters of the global model to each UAV client, repeating steps S2 to S4 until the preset global training rounds or model convergence threshold are reached to obtain the final fault diagnosis model. The UAV client collects real-time flight sensor data, inputs it into the fault diagnosis model, and outputs the UAV fault diagnosis result.

[0045] The principle of this solution is that during the system initialization phase, the global fault diagnosis model is decoupled into a feature extractor with shared parameters and a classifier with personalized parameters. At the architectural level, this balances the core advantages of federated learning's global knowledge collaboration with the client's personalized needs for adapting to heterogeneous data. Simultaneously, local data preprocessing is completed through standardization and sliding window data augmentation, ensuring the consistency of model input and training stability. During the client-side local training phase, the deviation between shared and personalized parameters is constrained, integrating local feature knowledge into the global shared parameters to resolve the mismatch between global parameter updates and local personalized parameters. Then, by calculating the parameter update consistency (PUC) value, coordinated parameters with consistent update directions from multiple rounds are selected. Only these coordinated parameters participate in local model updates, fundamentally filtering out invalid parameters caused by conflicting update directions due to heterogeneous data, preventing important parameter updates from being overwhelmed by irrelevant parameters. No, it achieves coordinated and unified local parameter updates; in the server aggregation stage, the trace quantification of each client model is first used to determine the information content and training adequacy of each client model. Based on this, the initial aggregation weights are allocated, which reduces the adverse effects of low participation and insufficient training clients on the global model in communication-constrained scenarios from the weight allocation level. Then, a global consensus region is constructed based on the coordinated parameter selectors of each client. The aggregation weights are optimized only in the parameter region where most clients reach an update consensus, further unifying the optimization direction of global aggregation, reducing aggregation bias caused by heterogeneous data, and completing the collaborative optimization of the global model. Finally, through multiple rounds of iterative client-server collaborative training, a UAV fault diagnosis model that balances privacy protection, heterogeneous data adaptability, and robustness in communication-constrained scenarios is obtained, which can be directly deployed on UAV clients to achieve local real-time fault diagnosis.

[0046] To address the parameter update conflict problem in heterogeneous data scenarios, this solution breaks through the conventional approach of existing personalized federated learning, which only separates shared and personalized parameters. It pioneers a federated parameter coordination mechanism of "bias constraint - coordinated parameter selection." Compared to traditional methods like FedAvg and FedProx, which only mitigate the impact of heterogeneity through weighted averaging or regularization constraints, this solution eliminates update conflicts caused by heterogeneous data at their root. In heterogeneous data scenarios with varying degrees of UAV faults, it achieves an average fault diagnosis accuracy improvement of 2.66%, particularly in scenarios with low feature discrimination and heterogeneity, such as hovering. Under harsh operating conditions, the accuracy improvement reached 3.66%, solving the industry pain point that existing technologies significantly reduce fault detection capabilities under stable flight conditions. Secondly, addressing the issue of low-participation clients weakening the overall training effect due to limited drone communication, this solution constructs a collaborative aggregation mechanism of "FIM initial weighting - consensus region optimization." This breaks through the inherent mode of existing technologies that weight aggregation based on data volume, achieving adaptive tilting of aggregation weights towards well-trained, active clients. Simultaneously, the global consensus region further unifies the aggregation optimization direction, resulting in a significant improvement compared to existing technologies in terms of client... To overcome the performance degradation issue caused by reduced client participation, this solution maintains an average fault diagnosis accuracy of 81.73% even in extremely communication-constrained scenarios with only 20% client participation. This represents a 19.12 percentage point improvement compared to the traditional FedAvg's 62.61%. Furthermore, when client participation decreases from 80% to 20%, the model accuracy drops by only 4.04%, far lower than FedAvg's 17.6 percentage point drop. This demonstrates exceptionally high model performance stability in communication-constrained scenarios, an unexpected technical achievement unattainable by existing technologies. Thirdly, this solution maintains consistent performance throughout the entire process... This method achieves collaborative training of models without disclosing the original local flight data of drones, balancing the dual requirements of drone data privacy protection and fault diagnosis performance. Compared with centralized fault diagnosis methods, it completely avoids the privacy leakage risk caused by uploading sensitive flight data. At the same time, compared with existing federated learning methods, it can still maintain high accuracy, strong robustness and good generalization in the dual extreme scenarios of heterogeneous data and limited communication. It is perfectly adapted to the complex working conditions and strict privacy and communication constraints of real drone flight scenarios in the low-altitude economy, providing reliable fault diagnosis technology support for drone flight safety.

[0047] The deviation between the shared parameters and the personalized parameters in step S2 specifically includes: for the t-th round of global training, the drone client uses the globally shared parameters from the (t-1)-th round. In local dataset Generate feature embeddings The feature embedding The expression is: In the formula, This represents the feature extraction mapping function of the feature extractor. Indicates the dimension of feature embedding. Indicates an active client Local dataset The number of samples, For the local dataset of the i-th client, For the (t-1)th round globally shared parameters received by the i-th client; construct the mean squared error loss function to constrain the t-th round globally shared parameters. Output and Feature Embedding The deviation is expressed by the loss function as follows: The globally shared parameters are updated using gradient descent based on the loss function. This approach enables shared parameters to learn local feature embedding knowledge and maintain coordination with personalized parameters. By constraining the deviation between shared and personalized parameters during local training, the global shared parameters can continuously absorb feature knowledge from the client's local data during iterative updates, maintaining alignment with the output of the local personalized classifier. This avoids the problem of mismatch between shared and personalized parameters and inconsistent model output caused by direct overwriting of global parameters. At the same time, it can effectively reduce the offset between local and global models caused by data heterogeneity, improve the stability of local training, and make subsequent parameter selection and global aggregation smoother, ultimately significantly improving the adaptability and accuracy of the fault diagnosis model.

[0048] Step S2, which calculates the parameter update consistency (PUC) value for each shared parameter, filters coordinated parameters based on the PUC value, and completes the local model parameter update, specifically includes: for the m-th shared parameter of the i-th client in the t-th round of global training. Calculate the consistency of its update directions across multiple rounds to obtain the corresponding PUC value. The calculation formula is: , This is an indicator function used to determine whether the change direction of locally shared parameters is a positive increment. The size of the sliding window used to record the update direction. This is the starting position of the sliding window; Let m be the update amount of the m-th shared parameter of the i-th client in round t. The preset starting position for the sliding window. threshold A coordination parameter selector is constructed based on the PUC value. The expression is

[0049] The update of locally shared parameters is performed based on the coordination parameter selector, and the update formula is as follows: ,in For the shared parameters updated by the i-th client, Let M be the shared parameters before the i-th client update, and M be the total number of shared parameters. By calculating the parameter update consistency (PUC) value and selecting coordinated parameters based on this value, only highly consistent parameters are retained to participate in local model updates. This can accurately identify and retain parameters with stable update directions and substantial contributions to model optimization in multiple iterations, while actively discarding invalid parameters that cause update direction conflicts due to heterogeneous client data and are prone to model degradation. This fundamentally alleviates the parameter update disorder caused by data heterogeneity, prevents important parameter updates from being overwhelmed by interfering parameters, and allows local model updates to focus more on effective information, improving model convergence stability and fault diagnosis accuracy. It also provides high-quality, highly consistent local parameters for subsequent server-side collaborative aggregation, ensuring the effectiveness of global model collaborative training.

[0050] Step S3 involves calculating the Fisher Information Matrix (FIM) of the local model and extracting the trace of the FIM as a measure of local information entropy. Specifically, this includes calculating the multi-class log-likelihood function based on the softmax output of the i-th client-side local model. The expression is: ,in, For the local model parameters of the i-th client, For local datasets In model parameters The probability density function is given below; the empirical Fisher information matrix (FIM) is calculated based on the gradient of the log-likelihood function, using the following formula: ,in, The log-likelihood function is relative to the model parameters. gradient, superscript This is a matrix transpose operation; the trace of the FIM matrix is ​​extracted as a local information entropy metric. The calculation formula is: ,in, The total dimension of the model parameters. The j-th element on the diagonal of the FIM matrix is ​​used to calculate the Fisher Information Matrix (FIM) and use its trace as a measure of local information entropy. This method can objectively quantify the effective information learned by each client model on local data and the degree of training sufficiency. It can accurately identify low-quality client updates with low participation and insufficient training in communication-constrained scenarios, avoid the global model offset problem caused by traditional data-weighted aggregation, automatically reduce the weight influence of weakly contributing clients and strengthen the parameter contributions of high-information-content clients during aggregation, significantly improve the reliability and stability of global model aggregation, and provide an objective weight basis for subsequent consensus region optimization. This allows the global model to maintain efficient convergence and high diagnostic accuracy under the dual challenges of communication constraints and data heterogeneity.

[0051] In step S4, the initial aggregation weight of each client is obtained by normalizing the information entropy metric value of each client. Specifically, this includes: normalizing the information entropy metric value of each client. Normalization is performed to obtain the initial aggregate weights for the i-th client. The calculation formula is: Where N is the total number of drone clients participating in this round of training; the initial aggregation update of shared parameters is completed based on the initial aggregation weights, and the formula is: in, These are the globally shared parameters after initial aggregation. These are the globally shared parameters used at the beginning of this training round. For the shared parameters updated locally by the i-th client, the initial aggregation weight is obtained by normalizing the information entropy metric of each client, and the initial aggregation update of the shared parameters is completed based on this weight. The aggregation weight can be dynamically allocated based on the actual effective information of the client, replacing the traditional weighting method based on data volume. This effectively suppresses the negative interference of low-participation and insufficiently trained clients on the global model under communication constraints, making the global shared parameter update more in line with the effective information of high-contribution clients, improving the rationality and stability of global model aggregation, and laying a reliable foundation for the personalized weight optimization in the subsequent consensus region. This ensures that the global model can still converge stably and maintain high fault diagnosis accuracy in heterogeneous data and weak communication environments.

[0052] Step S4, which involves constructing a global consensus region based on the coordination parameter selector of each client, specifically includes: for the m-th shared parameter, calculating the proportion of all clients that determine it as a coordination parameter. The calculation formula is: ,in, For indicator functions, The total number of drone clients participating in this round of training. The coordinating parameter selector for the m-th shared parameter of the i-th client; preset consensus threshold. Construct a global consensus mask The consensus parameter is identified by the following expression: ,all The corresponding shared parameters constitute a global consensus region. The optimization of aggregation weights and the final aggregation of the global model are only performed within the global consensus region. By constructing a global consensus region based on the parameter selector coordinated by each client, shared parameters that have consistent update directions among most clients and have global collaborative value can be accurately selected. Unstable parameters that are only recognized by a few clients and are prone to aggregation conflicts are excluded. From the aggregation scope, aggregation bias caused by data heterogeneity and low participation is further avoided. The global model completes its final optimization only within the highly collaborative consensus parameter range, which significantly improves the consistency and robustness of model aggregation. At the same time, it reduces the computation and communication overhead caused by invalid parameters, enabling the model to maintain efficient convergence and stable fault diagnosis performance even in complex UAV operating conditions and communication-limited scenarios.

[0053] In step S1, the feature extractor of the global fault diagnosis model consists of multiple one-dimensional convolutional layers, ReLU activation layers, and pooling layers, used to extract fault feature vectors from the time-series data of the UAV flight sensors; the classifier is a linear mapping layer, whose input dimension is consistent with the output dimension of the feature extractor, used to output fault category prediction results based on the fault feature vectors output by the feature extractor; the input of the model is the preprocessed UAV flight sensor time-series data x. Where T is the time step and C is the number of sensor channels; the mapping relationship of the feature extractor is as follows: , ,in Let d be the extracted fault feature vector, and d be the dimension of the fault feature vector; the mapping relationship of the classifier is as follows: ,in For fault diagnosis results, For the fault label space, the global fault diagnosis model is designed as a decoupled form of a one-dimensional convolutional feature extractor and a linear mapping classifier. This can efficiently adapt to the feature extraction requirements of UAV flight sensor time-series data. It uses one-dimensional convolutional layers, ReLU activation layers and pooling layers to accurately capture fault features in flight time-series signals, balancing feature extraction efficiency and nonlinear expression capabilities. At the same time, the decoupled architecture separates shared feature knowledge from local personalized classification, ensuring both collaborative training and knowledge sharing of the global model in federated learning, and meeting the personalized adaptation requirements of each client for local heterogeneous data. This allows the model to have both strong feature extraction capabilities and high fault classification accuracy under the premise of privacy protection, adapting to fault diagnosis scenarios of UAVs with multiple operating conditions and heterogeneous data.

[0054] Step S1 involves standardizing and performing sliding window data augmentation preprocessing on the local datasets of each client. Specifically, this includes: standardizing the original feature vectors using the Z-score standardization method to eliminate differences in feature dimensions. The standardization formula is as follows: ,in, Let j be the j-th dimension feature of the i-th sample in the original feature matrix. Let be the mean of the j-th feature across all samples. Let be the standard deviation of the j-th feature across all samples. Sliding window data augmentation is applied to the standardized data, with a sliding window size of 128 and a step size of 16. The resulting sample dimension is 12×128, where 12 represents the number of sensor feature channels, corresponding to the velocity, acceleration, angular velocity, and Euler angles in the x, y, and z directions of the UAV. Z-score standardization eliminates the dimensional and numerical differences among sensor features, unifying the input distribution, accelerating gradient descent convergence, and reducing training bias. Combined with sliding window augmentation of size 128 and step size 16, the multi-dimensional time-series signals of the UAV can be transformed into stable 12×128 input samples, fully preserving the temporal correlation features of the flight state and expanding the effective sample size. This allows the model to learn key fault information such as velocity, acceleration, angular velocity, and Euler angles more stably, significantly improving the convergence efficiency of federated training and the accuracy and robustness of fault diagnosis.

[0055] During the training process from steps S2 to S4, for scenarios where UAV communication is limited, active UAV clients are randomly selected in each round of global training to perform local training and information uploading according to a preset client participation ratio. Inactive clients do not participate in the training and global aggregation of this round. The client participation ratio ranges from 20% to 80%. In the training process from steps S2 to S4, active clients are randomly selected to participate in the training and aggregation of this round according to a preset ratio of 20% to 80%. This can closely match the limited scenarios in actual UAV flight, such as limited communication bandwidth, unstable signals, and temporary offline status of some nodes. It avoids communication congestion, excessive energy consumption, and training delays caused by the forced participation of all clients. It can also effectively avoid interference from low-participation and insufficiently trained clients on the global model update through dynamic screening. At the same time, it ensures that there are still a sufficient number of high-quality nodes participating in each round of aggregation, so that the global model can still converge stably and continuously optimize under communication-limited conditions. This greatly improves the environmental adaptability, training reliability, and engineering practicality of the entire federated fault diagnosis system.

[0056] In step S4, the optimization objective of personalized aggregated weights within the consensus region is to minimize the parameter differences between the local models of each client and the global model within the consensus region. Gradient descent is used for iterative optimization until the weight change is less than a preset threshold. Based on the optimized personalized aggregated weights, the final aggregation update of the global shared parameters is completed. The updated shared parameters of the global model are only distributed to the feature extractor modules of each drone client. The classifier module is independently trained and updated locally by each drone client. The optimization of personalized aggregated weights aims to minimize the parameter differences between the local models of the clients and the global model within the consensus region. It can further reduce the distribution deviation between the local model and the global model, making the globally shared parameters more aligned with the optimal update direction for multi-client collaboration. At the same time, the updated global model is only distributed to the feature extractor module, while the classifier is independently trained and updated locally by the client. This not only preserves the privacy protection and knowledge sharing advantages of federated learning, but also fully adapts to the heterogeneous characteristics of data from various clients. It significantly improves the personalized diagnostic accuracy of the model under different UAV fault conditions, and also reduces communication transmission volume and reduces the computing and communication energy consumption of the UAV. This makes the entire system have high accuracy, strong robustness and high execution efficiency in scenarios with heterogeneous data and limited communication.

[0057] In actual use

[0058] The UAV federated fault diagnosis method that integrates parameter coordination and collaborative aggregation disclosed in this embodiment is applied to a federated learning system containing a central server and N UAV clients. In this embodiment, N is set to 10 to adapt to the actual fault diagnosis operation scenario of multi-rotor UAV swarms under low-altitude economic conditions.

[0059] Implementation Environment and System Basic Configuration

[0060] Hardware and Communication Environment

[0061] Central server: A computing server equipped with an NVIDIA GeForce RTX 3090 graphics card, an Intel Core i9-10900K processor, and 64GB of RAM is used for the initialization, aggregation, updating, and encrypted distribution of the global fault diagnosis model, and runs the Ubuntu 20.04 LTS operating system.

[0062] Drone Client: Ten Droneeye X450 quadcopter drones are used. Each drone is equipped with a PX4 autopilot, an onboard GPS module, a 12-channel inertial measurement unit (IMU), and an onboard edge computing unit. The onboard unit is equipped with a quad-core ARM Cortex-A72 processor and 8GB of RAM, which can independently complete local model training, parameter calculation, and encrypted data interaction. Each drone locally stores an independent drone flight sensor time-series dataset and corresponding fault labels. All clients share the same fault label space, and the data among the clients is heterogeneous and not independent.

[0063] Communication architecture: The central server and the drone client use the AES-256 encrypted wireless communication protocol. The encrypted transmission of model parameters, metrics and selectors is completed based on 4G / 5G cellular networks or data radios. No original local flight data of the drone is transmitted throughout the process, thus avoiding the risk of privacy leakage of sensitive flight data from the source.

[0064] Software and Algorithm Environment

[0065] Both the central server and the drone client are deployed with Python 3.8 programming language, PyTorch 1.13.1 deep learning framework, and CUDA 11.6 parallel computing architecture. The federated learning collaborative training process is implemented based on the Flower 1.4.0 framework, data preprocessing is completed using NumPy 1.24 and Pandas 2.0 libraries, model training and optimization are implemented using Torch's built-in Adam optimizer, and encrypted communication is implemented based on the PyCryptodome library.

[0066] Datasets and Fault Labeling System

[0067] This embodiment uses hardware-in-the-loop (HIL) simulation data from the publicly available RflyMAD UAV anomaly dataset. The UAV physical parameters of this dataset are fully matched with those of the Droneyee X450 UAV. It includes full flight data under five typical flight conditions: acceleration, deceleration, hovering, constant speed, and circling. It covers two core UAV fault types: motor faults and wind disturbance faults. The fault severity is distributed in a continuous gradient, which is fully adapted to the real-world operation scenarios of UAVs.

[0068] Model input features: The velocity, acceleration, angular velocity and Euler angle of the UAV in the x, y and z directions are selected as the model input, corresponding to a 12-dimensional original feature vector, and the sampling frequency is 100Hz.

[0069] Fault Label Space: A total of 10 fault labels are set, including 1 category of normal flight status and 9 categories of different types and degrees of fault status. The 10 drone clients share this unified label space; each client corresponds to a unique fault severity parameter set, forming a naturally heterogeneous data distribution among the clients. The specific fault parameter division is as follows:

[0070] Motor failure scenario: The fault parameter range for the four boom motors is as follows: Parameter 0 indicates the motor is completely damaged, and 1 indicates the motor is working normally. The 10 clients correspond to the following:

[0071] , , , , , , , , , There are a total of 10 sets of heterogeneous parameters;

[0072] Wind disturbance fault scenarios include two types: stable wind faults and wind noise faults. Stable wind faults correspond to the wind speed parameters on the x, y, and z axes, while wind noise faults correspond to the wind amplitude disturbance factor and wind gain level parameters. The 10 clients correspond to wind disturbance parameters of different gradients, further enhancing the data heterogeneity among the clients.

[0073] Dataset partitioning: Each client's local dataset is divided into a training set and a test set in an 8:2 ratio. The training set is used for local federated model training, and the test set is used for offline verification of the model's fault diagnosis performance.

[0074] The UAV federation fault diagnosis method based on fusion parameter coordination and collaborative aggregation in this embodiment is fully implemented through the following steps:

[0075] S1: System Initialization and Data Preprocessing

[0076] This step consists of two core components: the construction and decoupling of the global fault diagnosis model, and the preprocessing of the local dataset. The specific implementation process is as follows:

[0077] Construction, decoupling, and distribution of a global fault diagnosis model

[0078] The central server builds and initializes a global fault diagnosis model, which is an end-to-end time-series data classification model. It is decoupled into two independent modules: a feature extractor containing shared parameters and a classifier containing individual parameters. The complete model parameters are represented as follows:

[0079] The specific architecture is as follows:

[0080] The feature extractor consists of three cascaded one-dimensional convolutional layers, ReLU activation layers, and max-pooling layers. It is used to extract robust fault feature vectors from UAV flight sensor time-series data. The first one-dimensional convolutional layer has a kernel size of 16, 32 output channels, and a stride of 2. The second one-dimensional convolutional layer has a kernel size of 8, 64 output channels, and a stride of 2. The third one-dimensional convolutional layer has a kernel size of 4, 128 output channels, and a stride of 1. Each convolutional layer is followed by a ReLU activation layer and a max-pooling layer with a kernel size of 2, ultimately outputting a fault feature vector with a dimension of 128. This dimension was determined experimentally: when the dimension is 64, the feature representation ability is insufficient, and the accuracy decreases by 3.2%; when the dimension is 256, the computational cost increases by 47%, but the accuracy only improves by 0.5%. Therefore, 128 was chosen as the optimal dimension. The mapping relationship of the feature extractor is as follows: , The model input x T is the time step, C=12 is the number of sensor channels; output The extracted fault feature vector is represented by 128, which is the fixed dimension of the fault feature vector.

[0081] Classifier: Employs a single linear mapping layer (fully connected layer) with an input dimension of 128 and an output dimension of 10, corresponding to 10 fault labels. This layer is used to predict fault categories based on the fault feature vectors output by the feature extractor. The mapping relationship of the classifier is as follows: ,in Y represents the fault diagnosis result, and Y is a 10-dimensional fault label space.

[0082] After model initialization, the central server sets the feature extractor parameters of the global fault diagnosis model to globally shared parameters and the classifier parameters to client-specific parameters. It then distributes the initialized complete global model to 10 drone clients via an AES-256 encrypted communication channel. Simultaneously, hyperparameter initialization is completed, and the global training rounds are set. Local training rounds on the client Local training learning rate Batch size .

[0083] Client-side local dataset preprocessing

[0084] After receiving the global model, each drone client performs normalization and sliding window data augmentation preprocessing on the locally stored raw sensor time-series dataset. The specific implementation process is as follows:

[0085] Z-score normalization: The original 12-dimensional feature vector is normalized using the Z-score normalization method to eliminate the dimensional differences of features from different sensors. The normalization formula is as follows: in, Let j be the j-th dimension feature of the i-th sample in the original feature matrix. Let be the mean of the j-th feature across all local samples on this client. Let be the standard deviation of the j-th feature across all local samples on this client; after standardization, each feature satisfies the distribution characteristics of zero mean and unit variance.

[0086] Sliding window data augmentation: Sliding window slicing augmentation is performed on the standardized time-series data. The sliding window size is set to 128 and the sliding step size is 16. Overlapping slices are performed on continuous time-series data. The resulting single sample dimension is fixed at 12×128, where 12 is the number of sensor feature channels and 128 is the number of time steps per sample. Through sliding window processing, the effective local training sample size is expanded, and the temporal correlation features of the UAV flight state are fully preserved, providing standardized input samples for model training.

[0087] S2: Client-side local federated parameter coordination training

[0088] For scenarios where UAV communication is restricted, each round of global training randomly selects active UAV clients to perform local training according to a preset client participation ratio. In this embodiment, the client participation ratio can be set as follows: Within the specified range, the value is set as needed, with a default value of 0.5. This means that in each round, 5 drones are randomly selected as active clients to perform local training, while inactive clients do not participate in this round of training or global aggregation. After the active clients complete data preprocessing, they perform multiple rounds of local training on the local dataset, which consists of two core steps:

[0089] Deviation constraints between shared and personalized parameters

[0090] For the t-th round of global training, the drone client first executes the deviation constraint between shared parameters and personalized parameters, so that the globally shared parameters learn local feature knowledge and maintain coordination with the personalized classifier parameters. The specific implementation steps are as follows:

[0091] Using the globally shared parameters issued in round t-1 In local dataset The feature embedding is generated by the feature extractor. The expression for feature embedding is: In the formula, The feature extraction mapping function of the feature extractor. For the local training dataset of the i-th client, The generated feature embedding is the global shared parameters received by the i-th client in the (t-1)-th round. Dimensions , This represents the number of samples in the local training set for this client.

[0092] Construct a mean squared error loss function and constrain the globally shared parameters in the t-th training round. Output and pre-generated feature embedding The deviation, the loss function expression is:

[0093] Based on the loss function described above, gradient descent is performed using the Adam optimizer to update the globally shared parameters. The gradient update formula is: In the formula, For the loss function relative to the shared parameters The gradient; through this step, the globally shared parameters fully learn the client's local feature embedding knowledge, ensuring that the output of the shared parameters is aligned with the local personalized classifier parameters, and avoiding the model consistency violation problem caused by global parameter coverage.

[0094] Coordination parameter filtering and local parameter updating based on PUC value

[0095] After completing the parameter deviation constraints, the client calculates the parameter update consistency PUC value for each shared parameter, selects and coordinates parameters based on the PUC value, and completes the local model parameter update. The specific implementation steps are as follows:

[0096] Calculate the parameter update consistency PUC value: for the m-th shared parameter of the i-th client in the t-th round of global training. Calculate the consistency of its update directions across multiple rounds to obtain the corresponding PUC value. The calculation formula is:

[0097] In the formula, The function is an indicator function that outputs 1 when the condition in parentheses is true and 0 when it is false. It is used to determine whether the change direction of the local shared parameter is a positive increment. T is the size of the sliding window used to record the update direction. In this embodiment, T=5. Let m be the update amount of the m-th shared parameter of the i-th client in round t; This represents the starting round of the sliding window; the PUC value ranges from [value missing]. The closer the value is to 1, the higher the consistency of the update direction of this parameter across multiple rounds.

[0098] Constructing a coordination parameter selector: A preset PUC threshold τ is used. In this embodiment, τ=0.4 for acceleration and hovering conditions, τ=0.85 for deceleration and constant speed conditions, and τ=0.95 for hovering conditions. A coordination parameter selector is constructed based on the PUC value and the threshold. The expression is: In the coordinating parameter selector, 1 indicates that the parameter is a coordinating parameter and can participate in this round of local model update; 0 indicates that the parameter is a non-coordinating parameter and will not participate in this round of update. Complete the local shared parameter update: Based on the coordinating parameter selector, complete the final update of the local shared parameters. The update formula is: In the formula, For the shared parameters updated by the i-th client, Let M be the number of shared parameters before the i-th client update. This step ensures that only coordinated parameters with consistent update directions from multiple rounds are retained for local model updates. This filters out invalid parameters caused by conflicting update directions due to heterogeneous data, preventing important parameter updates from being overwhelmed by irrelevant parameters. (PUC threshold) The value of the consensus threshold ε is positively correlated with the degree of data heterogeneity under the corresponding flight conditions: During acceleration and hovering, the UAV's flight state changes rapidly, fault feature differentiation is high, and data heterogeneity is low; therefore, the threshold is set to 0.4. During deceleration and constant speed, the flight state is stable, fault feature differentiation is moderate, and data heterogeneity is moderate; therefore, the threshold is set to 0.85. During hovering, the flight state is highly stable, fault feature differentiation is low, and data heterogeneity is high; therefore, the threshold is set to 0.95. By setting thresholds differentiated according to different flight conditions, invalid parameters can be filtered out while maximizing the retention of valid fault feature information, adapting to the heterogeneous characteristics of different flight conditions.

[0099] After local training is complete, the client fixes the classifier's personalized parameters and only retains the updated shared parameters for subsequent uploads.

[0100] S3: Client Information Upload

[0101] Each active drone client that has completed local training performs Fisher information matrix calculation and information upload. The specific implementation steps are as follows:

[0102] Calculate the Empirical Fisher Information Matrix (FIM) of the local model: First, calculate the multi-class log-likelihood function based on the softmax output of the i-th client-side local model, expressed as: In the formula, For the local model parameters of the i-th client, For local datasets In model parameters The probability density function is given below; the Fisher information matrix (FIM) is calculated based on the gradient of the log-likelihood function, using the following formula: In the formula, The log-likelihood function is relative to the model parameters. The gradient of , where the superscript T represents the matrix transpose operation.

[0103] Extracting the local information entropy metric: Extract the trace of the FIM matrix as the local information entropy metric. The calculation formula is: In the formula, The total dimension of the model parameters. It is the j-th element on the diagonal of the FIM matrix; this information entropy metric can objectively quantify the amount of effective information learned by the local model during training and the degree of training sufficiency.

[0104] Encrypted information upload: Each active client uploads the locally updated shared parameters, coordination parameter selector, and information entropy metric to the central server via an AES-256 encrypted channel, without transmitting the original local data or personalized classifier parameters.

[0105] S4: Server-side federated collaborative aggregation

[0106] After receiving the encrypted information uploaded by each active client, the central server decrypts the information and completes the federated collaborative aggregation. The specific implementation steps are as follows:

[0107] Initial aggregation weight allocation based on information entropy metric

[0108] The central server first normalizes the information entropy metric values ​​of each client to obtain the initial aggregation weights for each client. Specifically, this involves normalizing the information entropy metric values ​​of each client. Normalization is performed to obtain the initial aggregate weights for the i-th client. The calculation formula is: In the formula, The total number of active drone clients participating in this training round; based on the initial aggregation weights, the preliminary aggregation update of shared parameters is completed, using the following formula: In the formula, These are the globally shared parameters after initial aggregation. These are the globally shared parameters used at the beginning of this training round. This refers to the shared parameters updated locally by the i-th client. Through this step, the aggregation weights are dynamically allocated based on the actual effective information of the client, replacing the traditional weighting method based on data volume, and effectively suppressing the negative interference of low-participation and insufficiently trained clients on the global model.

[0109] A global consensus region is constructed based on the coordination parameter selector.

[0110] The central server constructs a global consensus region based on the coordination parameter selectors of each client. The specific implementation steps are as follows:

[0111] For the m-th shared parameter, calculate the proportion of all active clients that classify it as a coordination parameter. The calculation formula is: In the formula, Let N be the indicator function, and N be the total number of active drone clients participating in this training round. This is the coordinating parameter selector for the m-th shared parameter of the i-th client.

[0112] A preset consensus threshold ε is set. In this embodiment, ε=0.4 for acceleration and hovering conditions, ε=0.85 for deceleration and constant speed conditions, and ε=0.95 for hovering conditions. A global consensus mask M[m] is constructed to identify the consensus parameters, and its expression is: all The corresponding shared parameters constitute the global consensus region. In this round, the optimization of aggregate weights and the final aggregation of the global model are only carried out within the global consensus region. Parameters outside the consensus region do not participate in this round of aggregation optimization.

[0113] Weight optimization within the consensus region and final aggregation of the global model

[0114] Within the global consensus area, the initial aggregation weights are optimized to minimize the parameter differences between the local models of each client and the global model within the consensus area, resulting in personalized aggregation weights. Based on these optimized personalized aggregation weights, the final aggregation update of the globally shared parameters is completed, yielding the final global model for this round. After the aggregation update is complete, the central server encrypts and distributes the updated global model, containing only the shared parameters of the feature extractor, to each drone client. The classifier module of each client is independently trained and updated locally, without participating in global collaborative aggregation, further reducing communication transmission volume and adapting to the heterogeneous data characteristics of each client.

[0115] The specific process is as follows:

[0116] Construct an optimized loss function: In the formula, The Hadamard product is used to calculate parameter differences only within the consensus region; M is the global consensus mask. This indicates that the m-th parameter is a consensus parameter. Indicates non-consensus parameters; These are the initial aggregation weights calculated based on the FIM trace; These are the shared parameters updated locally on the i-th client; These are the globally shared parameters after initial aggregation.

[0117] Initialize personalized aggregate weights Set the optimal learning rate Maximum number of iterations Convergence threshold .

[0118] Iteratively update weights: Where, gradient The calculation formula is

[0119] Termination condition: when or When the time is reached, the optimization is terminated, and the final personalized aggregate weight is obtained. .

[0120] The final aggregation is completed based on the optimized weights:

[0121] In this embodiment, the optimization process converges in an average of 12 iterations, and the time taken for a single round of optimization is less than 0.5 seconds, which does not increase the time cost of global training.

[0122] After the aggregation update is completed, the central server encrypts and distributes the shared parameters of the updated global model to each drone client. The classifier module of the client is independently trained and updated locally by each drone and does not participate in the global collaborative aggregation, which further reduces the amount of communication transmission and adapts to the heterogeneous data characteristics of each client.

[0123] S5: Iterative Training and Fault Diagnosis

[0124] Iterative Collaborative Training

[0125] After the central server sends the updated global shared parameters to each drone client, it repeats steps S2 to S4 until the preset 50 rounds of global training are reached, or the model's fault diagnosis accuracy on the test set improves by less than 0.1% for 5 consecutive rounds. At this point, the model is considered to have converged, training is terminated, and the final fault diagnosis model is obtained.

[0126] Real-time fault diagnosis of drones

[0127] After training, the final fault diagnosis model is deployed to the onboard edge computing unit of each drone client to perform real-time fault diagnosis. The specific process is as follows:

[0128] The UAV's onboard sensors collect real-time flight timing data in the x, y, and z directions at a frequency of 100Hz, including velocity, acceleration, angular velocity, and Euler angles in the x, y, and z directions, totaling 12 channels.

[0129] The airborne unit performs Z-score normalization and sliding window slicing on the raw data acquired in real time, consistent with the training phase, to obtain real-time input samples with a dimension of 12×128.

[0130] The real-time input samples are input into the deployed fault diagnosis model. First, the fault feature vector is extracted by the feature extractor, and then the fault category prediction result is output by the local personalized classifier to complete the real-time fault diagnosis of the UAV.

[0131] When the model outputs an abnormal state as the fault category, the airborne flight control system triggers the corresponding level of fault warning and emergency response strategy to ensure the flight safety of the UAV.

[0132] Verification of the implementation effect of this embodiment

[0133] To fully verify the technical effects of the present invention, this embodiment sets up two sets of control experiments to verify the performance of the present invention in a pure data heterogeneous scenario and a dual scenario of communication limitation and data heterogeneity. All experiments use the same hardware environment, dataset, model architecture and training hyperparameters to ensure the reproducibility of experimental results and the fairness of comparison.

[0134] Performance verification in pure data heterogeneous scenarios

[0135] In this experimental scenario, all 10 drone clients participated in the training in each round of global training (100% client participation). The only issue was the heterogeneity of fault data between clients, and there was no problem of reduced client participation due to communication limitations. The experimental conditions were: 50 rounds of global training, 10 rounds of local training, a training set / test set ratio of 8:2, and coverage of 5 typical flight conditions: acceleration, deceleration, hovering, constant speed, and circling.

[0136] This experiment selects five mainstream federated learning methods—FedAvg, FedProx, FedPer, FedProto, and FedAS—for comparison, and conducts a multi-dimensional performance comparison with the FedPHSA method proposed in this invention. Core performance indicators include fault diagnosis accuracy, precision, recall, and F1-Score. Specific performance data for each method are as follows:

[0137] Table 1 compares the fault diagnosis accuracy of different federated learning methods in a purely heterogeneous data scenario.

[0138]

[0139] Table 2 Comparison of Fault Diagnosis Accuracy of Different Federated Learning Methods in Pure Data Heterogeneous Scenarios

[0140]

[0141] Table 3 Comparison of Fault Diagnosis Recall Rates of Different Federated Learning Methods in Pure Data Heterogeneous Scenarios

[0142]

[0143] Table 4. Comparison of F1-Scores for Fault Diagnosis of Different Federated Learning Methods in Pure Data Heterogeneous Scenarios

[0144] The experimental data above shows that, in a purely heterogeneous data scenario, the FedPHSA method proposed in this invention achieves an average accuracy of 86.45% across five flight conditions, representing improvements of 2.66%, 2.77%, 1.92%, and 2.02% respectively compared to traditional FedAvg, FedProx, FedPer, and FedProto methods. In the hovering condition, characterized by low feature discrimination and the strongest heterogeneity, the accuracy reaches 85.31%, representing the highest improvement of 3.66% compared to the comparison methods, thus addressing the industry pain point of significantly reduced fault detection capability under stable flight conditions in existing technologies. Furthermore, this invention comprehensively outperforms all comparison methods in the three core indicators of accuracy, recall, and F1-Score, demonstrating that it possesses both extremely high fault diagnosis accuracy and model stability in heterogeneous data scenarios.

[0145] Performance verification under dual scenarios of limited communication and heterogeneous data

[0146] In this experimental scenario, a communication-constrained environment was simulated during real-world drone flight. Client participation gradients were set to 0.2, 0.4, 0.6, and 0.8, corresponding to 20%, 40%, 60%, and 80% of drone clients randomly participating in training in each round, respectively. Data heterogeneity among clients was preserved. The global training consisted of 50 rounds, and the local training consisted of 10 rounds, with a training set / test set ratio of 8:2. Five typical flight conditions—acceleration, deceleration, hovering, constant speed, and circling—were covered. This experiment compared five mainstream federated learning methods—FedAvg, FedProx, FedPer, FedProto, and FedAS—with the proposed FedPHSA method across multiple dimensions. Key performance indicators included fault diagnosis accuracy, precision, recall, and F1-Score under different client participation levels. Specific performance data for each method are as follows:

[0147] Table 5 Comparison of fault diagnosis accuracy of different federated learning methods in communication-constrained scenarios.

[0148]

[0149] Table 6 compares the fault diagnosis accuracy of different federated learning methods in communication-constrained scenarios.

[0150]

[0151] Table 7 compares the recall rates of different federated learning methods for fault diagnosis in communication-constrained scenarios.

[0152]

[0153] Table 8 compares the F1-Scores of different federated learning methods for fault diagnosis in communication-constrained scenarios.

[0154]

[0155] Experimental results show that as the proportion of client participation in training decreases, the performance of existing mainstream federated learning algorithms all show a significant downward trend. Among them, the FedAvg algorithm's average accuracy drops from 80.4% to 62.61% when the client activity level decreases from 0.8 to 0.2, with an overall decrease of 17.6 percentage points. In contrast, the FedPHSA method proposed in this invention can still maintain an average fault diagnosis accuracy of 81.73% in the extreme communication-constrained scenario where only 20% of clients participate, which is 19.12 percentage points higher than the traditional FedAvg. When the client participation level decreases from 0.8 to 0.2, the accuracy of the model proposed in this invention decreases by only 4.04%, which is far lower than the performance decline of existing methods, achieving ultra-high stability of model performance in communication-constrained scenarios.

[0156] To verify the technical contributions of the two core modules of this scheme—the parameter coordination mechanism and the collaborative aggregation mechanism—an ablation experiment was conducted in this embodiment. Variants of the construction methods for each of the two core modules were removed, and performance was compared under the same experimental conditions. Experimental results show that after removing both the parameter coordination mechanism and the collaborative aggregation mechanism simultaneously, the method's performance is essentially on par with the traditional FedAvg. However, when only the collaborative aggregation mechanism is removed, the method's performance decreases by more than 15% in communication-constrained scenarios. Furthermore, when only the parameter coordination mechanism is removed, the method's performance decreases by more than 8% in data heterogeneous scenarios. This fully demonstrates that both core modules of this invention possess irreplaceable technical value, and their combination achieves a performance breakthrough in both data heterogeneous and communication-constrained scenarios.

Claims

1. A method for federated fault diagnosis of unmanned aerial vehicles (UAVs) integrating parameter coordination and collaborative aggregation, applied to a federated learning system comprising a central server and N UAV clients, wherein each UAV client locally stores an independent UAV flight sensor time-series dataset and corresponding fault labels, all clients share the same fault label space and the data among clients are heterogeneously distributed, characterized in that, The method includes the following steps: S1: System initialization. The central server builds and initializes a global fault diagnosis model, decoupling the global fault diagnosis model into a feature extractor containing shared parameters and a classifier containing personalized parameters. The central server encrypts and distributes the initialized global model to each UAV client. Each UAV client preprocesses its local dataset to obtain model input samples. S2: Client-side local federated parameter coordination training. After receiving the global model, each participating drone client performs multiple rounds of local training on the local dataset. During the training process, the deviation between shared parameters and personalized parameters is first constrained, and then the parameter update consistency PUC value of each shared parameter is calculated. Based on the PUC value, the coordinated parameters are selected and the local model parameter update is completed. S3: Client information upload. Each drone client that has completed local training calculates the Experience Fisher Information Matrix (FIM) of its local model, extracts the trace of the FIM as the local information entropy metric, and simultaneously uploads the locally updated shared parameters, coordination parameter selector, and information entropy metric to the central server in encryption. S4: Server-side federated collaborative aggregation. After receiving information uploaded by each client, the central server first normalizes the information entropy metric of each client to obtain the initial aggregation weight of each client. Then, it constructs a global consensus region based on the coordination parameter selector of each client. Within the consensus region, gradient descent is used to optimize and obtain personalized aggregation weights with the goal of minimizing the parameter differences between the local model of each client and the global model within the consensus region. Finally, the aggregation update of the global model is completed based on the optimized aggregation weights. S5: Iterative training and fault diagnosis. The central server distributes the updated shared parameters of the global model to each UAV client, repeating steps S2 to S4 until the preset global training rounds or model convergence threshold are reached to obtain the final fault diagnosis model. The UAV client collects real-time flight sensor data, inputs it into the fault diagnosis model, and outputs the UAV fault diagnosis result.

2. The UAV federated fault diagnosis method based on fusion parameter coordination and collaborative aggregation according to claim 1, characterized in that, The deviation between the shared parameters and the personalized parameters in step S2 specifically includes: for the t-th round of global training, the drone client uses the globally shared parameters from the (t-1)-th round. In local dataset Generate feature embeddings The feature embedding The expression is: In the formula, This represents the feature extraction mapping function of the feature extractor. Indicates the dimension of feature embedding. Indicates an active client Local dataset The number of samples, For the local dataset of the i-th client, For the (t-1)th round of globally shared parameters received by the i-th client; construct the mean squared error loss function to constrain the t-th round of globally shared parameters. Output and Feature Embedding The deviation, the loss function expression is: The globally shared parameters are updated using gradient descent based on the loss function. This enables shared parameters to learn local feature embedding knowledge and maintain consistency with personalized parameters.

3. The UAV federated fault diagnosis method based on fusion parameter coordination and collaborative aggregation according to claim 2, characterized in that, Step S2, which calculates the parameter update consistency (PUC) value for each shared parameter, filters coordinated parameters based on the PUC value, and completes the local model parameter update, specifically includes: for the m-th shared parameter of the i-th client in the t-th round of global training. Calculate the consistency of its update directions across multiple rounds to obtain the corresponding PUC value. The calculation formula is: , This is an indicator function used to determine whether the change direction of locally shared parameters is a positive increment. The size of the sliding window used to record the update direction. This is the starting position of the sliding window; Let m be the update amount of the m-th shared parameter of the i-th client in round t. The preset starting position for the sliding window. threshold A coordination parameter selector is constructed based on the PUC value. The expression is The update of locally shared parameters is completed based on the coordination parameter selector, and the update formula is as follows: ,in For the shared parameters updated by the i-th client, Let M be the shared parameters before the i-th client updates, and M be the total number of shared parameters.

4. The UAV federated fault diagnosis method based on fusion parameter coordination and collaborative aggregation according to claim 1, characterized in that, Step S3, which involves calculating the Fisher Information Matrix (FIM) of the local model and extracting the trace of the FIM as a measure of local information entropy, specifically includes: calculating the multi-class log-likelihood function based on the softmax output of the i-th client-side local model. The expression is: ,in, For the local model parameters of the i-th client, For local datasets In model parameters The probability density function is given below; the empirical Fisher information matrix (FIM) is calculated based on the gradient of the log-likelihood function, using the following formula: in, The log-likelihood function is relative to the model parameters. gradient, superscript This is a matrix transpose operation; the trace of the FIM matrix is ​​extracted as a local information entropy metric. The calculation formula is: ,in, The total dimension of the model parameters. It is the j-th element on the diagonal of the FIM matrix.

5. The UAV federated fault diagnosis method based on fusion parameter coordination and collaborative aggregation according to claim 4, characterized in that, In step S4, the initial aggregation weight of each client is obtained by normalizing the information entropy metric value of each client. Specifically, this includes: normalizing the information entropy metric value of each client. Normalization is performed to obtain the initial aggregate weights for the i-th client. The calculation formula is: Where N is the total number of drone clients participating in this round of training; the initial aggregation update of shared parameters is completed based on the initial aggregation weights, and the formula is: in, These are the globally shared parameters after initial aggregation. These are the globally shared parameters used at the beginning of this training round. These are the shared parameters updated locally on the i-th client.

6. The UAV federated fault diagnosis method based on fusion parameter coordination and collaborative aggregation according to claim 3, characterized in that, Step S4, which involves constructing a global consensus region based on the coordination parameter selector of each client, specifically includes: for the m-th shared parameter, calculating the proportion of all clients that determine it as a coordination parameter. The calculation formula is: ,in, For indicator functions, The total number of drone clients participating in this round of training. For the i-th client, a coordinating parameter selector for the m-th shared parameter; a preset consensus threshold. Construct a global consensus mask The consensus parameter is identified by the following expression: ,all The corresponding shared parameters constitute the global consensus region, and the optimization of aggregate weights and the final aggregation of the global model are only performed within the global consensus region.

7. The UAV federated fault diagnosis method based on fusion parameter coordination and collaborative aggregation according to claim 1, characterized in that, In step S1, the feature extractor of the global fault diagnosis model consists of multiple one-dimensional convolutional layers, ReLU activation layers, and pooling layers, used to extract fault feature vectors from the time-series data of the UAV flight sensors; the classifier is a linear mapping layer, whose input dimension is consistent with the output dimension of the feature extractor, used to output fault category prediction results based on the fault feature vectors output by the feature extractor; the input of the model is the preprocessed UAV flight sensor time-series data x. Where A is the number of time steps and C is the number of sensor channels; the mapping relationship of the feature extractor is as follows: , ,in Let d be the extracted fault feature vector, and d be the dimension of the fault feature vector; the mapping relationship of the classifier is as follows: ,in For fault diagnosis results, This is the fault label space.

8. The UAV federated fault diagnosis method based on fusion parameter coordination and collaborative aggregation according to claim 1, characterized in that, In step S1, the preprocessing employs a combination of Z-score standardization and sliding window data augmentation. Specifically, it includes: standardizing the original feature vector using the Z-score standardization method to eliminate differences in feature dimensions. The standardization formula is: in, Let j be the j-th dimension feature of the i-th sample in the original feature matrix. Let be the mean of the j-th feature across all samples. Let be the standard deviation of the j-th feature across all samples; then, slide window data augmentation is performed on the standardized data, with the slide window size set to 128 and the step size to 16. The resulting sample dimension is 12×128, where 12 represents the number of sensor feature channels, corresponding to the velocity, acceleration, angular velocity, and Euler angles in the x, y, and z directions of the UAV.

9. The UAV federated fault diagnosis method based on fusion parameter coordination and collaborative aggregation according to claim 1, characterized in that, During the training process from steps S2 to S4, for scenarios where UAV communication is restricted, each round of global training randomly selects active UAV clients to perform local training and information uploading according to a preset client participation ratio. Inactive clients do not participate in the training and global aggregation of this round. The value range of the client participation ratio is 20% to 80%.

10. The UAV federated fault diagnosis method based on fusion parameter coordination and collaborative aggregation according to claim 1, characterized in that, In step S4, the optimization objective of optimizing the personalized aggregation weights within the consensus region is to minimize the parameter differences between the local models of each client and the global model within the consensus region. The gradient descent method is used to iteratively optimize until the weight change is less than a preset threshold. Based on the optimized personalized aggregation weights, the final aggregation update of the global shared parameters is completed. The shared parameter part of the updated global model is only distributed to the feature extractor module of each drone client, and the classifier module is independently trained and updated locally by each drone client.

Images