Model training method, fault detection method, fault detection device, storage medium and program product

Abstract

The invention provides a model training method, a fault detection method, a fault detection device, a storage medium and a program product. The method comprises the following steps: receiving a to-be-updated global fault diagnosis model sent by a central server and an initial feature vector set corresponding to each state category; collecting a sample private data set from a data service node managed by a local server; based on the sample private data set and the plurality of initial feature vector sets, training a to-be-updated global fault diagnosis model to obtain a target local fault diagnosis model, and determining a model parameter update quantity of the target local fault diagnosis model relative to the to-be-updated global fault diagnosis model; and sending the model parameter update quantity to a central server, so that the central server updates the to-be-updated global fault diagnosis model based on the received model parameter update quantity to obtain a target global fault diagnosis model when the number of the received model parameter update quantity is greater than or equal to a target threshold value.

Description

Model training methods, fault detection methods, fault detection equipment, storage media and program products Technical Field

[0001] This application relates to artificial intelligence technology, and more particularly to a model training method, a fault detection method, a fault detection device, a storage medium, and a program product. Background Technology

[0002] Fault detection and diagnosis technologies are crucial for ensuring the reliable and stable operation of complex systems, especially large-scale storage systems. With the explosive growth of data volume and the increasing complexity of storage system architectures, traditional machine learning-based fault diagnosis methods heavily rely on massive amounts of data for model training and prediction. This data is often scattered across different vendors or data centers and contains a large amount of sensitive or private information. Against the backdrop of frequent data security incidents and increasingly stringent regulations, data owners' emphasis on privacy protection has led to a serious data silo problem, preventing the effective aggregation and sharing of cross-domain data. Furthermore, in distributed environments, the data scale and computing power of each node differ, and traditional centralized training or synchronous update strategies can severely hinder overall modeling efficiency by waiting for slower nodes. Summary of the Invention

[0003] This application provides a model training method, a fault detection method, a fault detection device, a storage medium, and a program product, which not only protect data privacy and break down data barriers, but also improve training efficiency and response speed.

[0004] The technical solution of this application embodiment is implemented as follows: This application embodiment provides a model training method applied to a local server. The method includes: receiving a global fault diagnosis model to be updated and an initial feature vector set corresponding to each state category sent by a central server; wherein, the initial feature vector set is extracted from the global fault diagnosis model to be updated and represents the feature representation of various state modes; the state categories include normal state, permanent fault, intermittent fault, and transient fault; collecting a sample private data set from the data service nodes managed by the local server; training the global fault diagnosis model to be updated based on the sample private data set and multiple initial feature vector sets to obtain a target local fault diagnosis model, and determining the model parameter update amount of the target local fault diagnosis model relative to the global fault diagnosis model to be updated; wherein, the target local fault diagnosis model is used to perform fault detection on the data service nodes; sending the model parameter update amount to the central server, so that when the number of received model parameter update amounts is greater than or equal to a target threshold, the central server updates the global fault diagnosis model to be updated based on the received model parameter update amounts to obtain the target global fault diagnosis model.

[0005] In the above scheme, training the global fault diagnosis model to be updated based on the sample private data set and multiple initial feature vector sets to obtain the target local fault diagnosis model includes: using a probabilistic neural network model, determining the probability density estimate of each sample private data belonging to each state category based on the sample private data set and the feature vector sets; wherein, both the global fault diagnosis model to be updated and the target local fault diagnosis model include the probabilistic neural network model; adjusting the parameters of the global fault diagnosis model to be updated based on the probability density estimate to obtain the target local fault diagnosis model.

[0006] In the above scheme, the step of using a probabilistic neural network model to determine the probability density estimate of each sample private data belonging to each state category based on the sample private data set and the feature vector set includes: determining the probability density estimate of each sample private data belonging to each state category based on a Gaussian function, the sample private data set, and multiple initial feature vector sets; wherein, the probabilistic neural network model is a probabilistic neural network model that uses the Gaussian function as the activation function.

[0007] In the above scheme, determining the probability density estimate of each sample private data belonging to each state category based on the Gaussian function, the sample private data set, and multiple initial feature vector sets includes: for each sample private data, calculating the distance between the sample private data and each feature vector in each initial feature vector set to obtain multiple distance values; for each distance value, transforming the distance value using a Gaussian function to obtain the Gaussian function value corresponding to the distance value; and for each state category, obtaining the probability density estimate of the sample private data belonging to the state category based on the multiple Gaussian function values ​​corresponding to the state category.

[0008] In the above scheme, obtaining the probability density estimate of the sample private data belonging to the state category based on the multiple Gaussian function values ​​corresponding to the state category includes: for each state category, summing the multiple Gaussian function values ​​corresponding to the state category to obtain the total Gaussian function value of the state category; and normalizing the total Gaussian function value to obtain the probability density estimate.

[0009] A model training method is applied to a central server. The method includes: generating a global fault diagnosis model to be updated based on sample general data, and extracting an initial feature vector set corresponding to each state category from the global fault diagnosis model to be updated; sending the global fault diagnosis model to be updated and the initial feature vector set to at least one local server, so that each local server trains the global fault diagnosis model to be updated based on its own sample private data; receiving model parameter update amounts of a target local fault diagnosis model relative to the global fault diagnosis model to be updated sent by multiple local servers; when the number of received model parameter update amounts is greater than or equal to a target threshold, performing aggregated updates on the global fault diagnosis model to be updated based on the received model parameter update amounts, until a target global fault diagnosis model is obtained.

[0010] A fault detection method is applied to a local server. The method further includes: receiving a set of target feature vectors corresponding to each state category extracted from a target global fault diagnosis model sent by a central server; collecting private data to be diagnosed from data service nodes managed by the local server; and performing fault detection on the private data to be diagnosed using a target local fault diagnosis model and the set of target feature vectors to obtain the target state category of the data service node. The target local fault diagnosis model is trained using the model training method described above, and the target global fault diagnosis model is trained using the model training method described above.

[0011] This application provides a first model training apparatus, comprising: a first receiving unit, configured to receive a global fault diagnosis model to be updated and an initial feature vector set corresponding to each state category sent by a central server; wherein the initial feature vector set is extracted from the global fault diagnosis model to be updated and represents the feature representation of various state modes; the state categories include normal state, permanent fault, intermittent fault, and transient fault; a first acquiring unit, configured to collect a sample private data set from data service nodes managed by the local server; a first training unit, configured to train the global fault diagnosis model to be updated based on the sample private data set and multiple initial feature vector sets to obtain a target local fault diagnosis model, and determine the model parameter update amount of the target local fault diagnosis model relative to the global fault diagnosis model to be updated; wherein the target local fault diagnosis model is used to perform fault detection on the data service nodes; and a first sending unit, configured to send the model parameter update amount to the central server, so that when the number of received model parameter update amounts is greater than or equal to a target threshold, the central server updates the global fault diagnosis model to be updated based on the received model parameter update amounts to obtain the target global fault diagnosis model.

[0012] This application provides a second model training apparatus, comprising: a first determining unit, configured to generate a global fault diagnosis model to be updated based on sample general data, and extract an initial feature vector set corresponding to each state category from the global fault diagnosis model to be updated; a second sending unit, configured to send the global fault diagnosis model to be updated and the initial feature vector set to at least one local server, so that each local server trains the global fault diagnosis model to be updated based on its own sample private data; a second receiving unit, configured to receive model parameter update amounts of a target local fault diagnosis model relative to the global fault diagnosis model to be updated sent by multiple local servers; and a second training unit, configured to perform aggregate updates on the global fault diagnosis model to be updated based on the received model parameter update amounts when the number of received model parameter update amounts is greater than or equal to a target threshold, until a target global fault diagnosis model is obtained.

[0013] This application provides a fault detection device, comprising: a third receiving unit for receiving a set of target feature vectors corresponding to each state category extracted from a target global fault diagnosis model, sent by a central server; a second acquiring unit for collecting private data to be diagnosed from data service nodes managed by the local server; and a second determining unit for performing fault detection on the private data to be diagnosed using a target local fault diagnosis model and the set of target feature vectors to obtain the target state category of the data service node; wherein the target local fault diagnosis model and the target global fault diagnosis model are trained respectively using the above-described model training method.

[0014] This application provides a local server, which includes: a memory for storing computer-executable instructions or computer programs; and a processor for executing the computer-executable instructions or computer programs stored in the memory to implement the model training method or fault detection method provided in this application.

[0015] This application provides a computer-readable storage medium storing a computer program or computer-executable instructions, which, when executed by a processor, implements the model training method or fault detection method provided in this application.

[0016] This application provides a central server, which includes: a memory for storing computer-executable instructions or computer programs; and a processor for executing the computer-executable instructions or computer programs stored in the memory to implement the model training method provided in this application.

[0017] This application provides a computer-readable storage medium storing a computer program or computer-executable instructions for implementing the model training method provided in this application when executed by a processor.

[0018] This application provides a computer program product, including a computer program or computer executable instructions. When the computer program or computer executable instructions are executed by a processor, they implement the model training method or fault detection method provided in this application.

[0019] The embodiments of this application have the following beneficial effects: The local server uses its private data and the initial feature vector set distributed by the central server to train the received global model to be updated, and calculates the model parameter update amount and sends it back to the central server. That is, the local server and the central server do not need to share sensitive original private data, but only exchange model parameter update amounts, which fundamentally protects data privacy and breaks down data barriers. At the same time, it allows the central server to perform global model optimization after receiving a certain number of model parameter updates, without having to wait to receive model parameter updates sent by all local servers before performing global model optimization. This greatly alleviates the synchronization waiting problem caused by node heterogeneity and significantly improves training efficiency and response speed. Attached Figure Description

[0020] Figure 1 is a schematic flowchart of a model training process provided in an embodiment of this application; Figure 2 is a schematic flowchart of the interaction between a local server and a central server in a model training process provided in an embodiment of this application; Figure 3 is a schematic flowchart of another model training process provided in an embodiment of this application; Figure 4 is a schematic flowchart of a fault detection process provided in an embodiment of this application; Figure 5 is a schematic flowchart of yet another model training process provided in an embodiment of this application; Figure 6 is a schematic structural diagram of a first model training device provided in an embodiment of this application; Figure 7 is a schematic structural diagram of a second model training device provided in an embodiment of this application; Figure 8 is a schematic structural diagram of a fault detection device provided in an embodiment of this application; Figure 9 is a schematic structural diagram of a local server provided in an embodiment of this application; Figure 10 is a schematic structural diagram of a central server provided in an embodiment of this application; Figure 11 is a schematic structural diagram of yet another local server provided in an embodiment of this application. Detailed Implementation

[0021] To make the objectives, technical solutions, and advantages of this application clearer, the application will be further described in detail below with reference to the accompanying drawings. The described embodiments should not be regarded as limitations on this application. All other embodiments obtained by those skilled in the art without creative effort are within the scope of protection of this application.

[0022] Based on the foregoing embodiments, this application provides a model method applied to a local server. Referring to Figure 1, it can be implemented in the following way: Step 101: Receive the global fault diagnosis model to be updated and the initial feature vector set corresponding to each state category sent by the central server.

[0023] The initial feature vector set is extracted from the global fault diagnosis model to be updated and represents the feature representation of various state modes; the state categories include normal state, permanent fault, intermittent fault and transient fault.

[0024] In this embodiment, the central server refers to a central coordinating node with strong computing and storage capabilities within the federated learning framework; the local server refers to a server deployed in the storage cluster, responsible for managing some nodes within its own cluster; the global fault diagnosis model to be updated is an initial machine learning model for fault diagnosis, trained by the central server on a federated learning (FL) model created based on a sample general dataset, specifically a probabilistic neural network (PNN) model; the state category (which can be...) It means, and This refers to the possible operating states of data service nodes in the local storage cluster of a local server, specifically including the normal state (i.e., ), permanent fault ( Intermittent faults (i.e.) ) and transient faults (i.e. The initial feature vector set refers to the set of feature vectors extracted from the global fault diagnosis model to be updated, used to characterize the typical patterns of each state category, and can be represented as follows: , specifically The set of feature vectors representing the normal state. The set of feature vectors representing permanent faults. The set of feature vectors representing intermittent faults. The set of feature vectors representing transient faults, where each initial feature vector is a d-dimensional feature vector and the number of initial feature vectors for each state category is k.

[0025] In this embodiment, the central server can send the global fault diagnosis model to be updated and the initial feature vector set corresponding to each state category to multiple local servers. For each local server (as shown in Figure 2, which is usually a monitor node in the storage cluster), it can download the global fault diagnosis model to be updated and the initial feature vector set corresponding to each state category from the central server. It should be noted that this step is the beginning of federated learning collaborative training, and the local servers obtain a unified initial model and classification benchmark.

[0026] Step 102: Collect a set of sample private data from the data service nodes managed by the local server.

[0027] In this embodiment, referring to Figure 2, a local storage cluster refers to a distributed system that provides data storage services, consisting of multiple storage nodes (such as monitor, object storage gateway (rgw), and object storage daemon (osd)), with each local server managing one of the clusters; the sample private data set refers to historical or real-time monitoring data (such as performance metrics and error logs) collected from the local storage cluster, reflecting the operating status of each node, and this data typically contains sensitive information, specifically represented as... The local server collects a private sample data set from the data service nodes it manages (such as rgw, osd, etc.). The rgw and osd nodes are the sources of the private sample data set. This data reflects the unique operating mode and fault characteristics of the cluster and is the basis for subsequent localized training.

[0028] Step 103: Based on the sample private data set and multiple initial feature vector sets, train the global fault diagnosis model to be updated to obtain the target local fault diagnosis model, and determine the model parameter update amount of the target local fault diagnosis model relative to the global fault diagnosis model to be updated.

[0029] Among them, the target local fault diagnosis model is used to detect faults in the data service nodes managed by the local server.

[0030] In this embodiment, the target local fault diagnosis model refers to a fault diagnosis model adapted to the current storage cluster, obtained after training with sample private data. This model not only inherits the general capabilities of the global model but also incorporates local features. The model parameter update amount refers to the change in parameters of the target local fault diagnosis model relative to the initially received global model. The local server is responsible for training the local model and interacting with the central server. Specifically, the local server loads the received global fault diagnosis model to be updated into its local memory. This model is a probabilistic neural network model, and its structure (such as the number of layers, feature dimensions, and smoothing parameters) can be customized. The initial values ​​(represented by the central server) are defined by the central server. Simultaneously, the local server loads the initial feature vector set issued by the central server. Then, the local server uses its collected private sample data set (such as private sample data from RGW and OSD nodes) to iteratively train the model. Essentially, this training utilizes local data (i.e., private sample data) to calibrate or fine-tune the PNN model, primarily adjusting the model's internal parameters (especially the smoothing parameter). Instead of changing the model structure, and after fine-tuning through multiple iterations, the local server obtains a PNN model with optimized parameters that is better suited to the local data distribution, which is the target local fault diagnosis model.

[0031] In this embodiment, before training begins, the local server saves a complete parameter copy of the global fault diagnosis model to be updated, received from the central server, as a baseline. For the PNN model, key parameters typically include: smoothing parameters and an initial feature vector set. After obtaining the trained target local fault diagnosis model, the local server compares the parameters of the trained target local fault diagnosis model with the saved baseline parameters item by item, calculates the differences, and then updates all calculated parameters (such as...). and all The data is packaged into a structured data block, which is the model parameter update amount; that is, the model parameter update amount includes at least the update amount of the smoothing parameters and the update amount of the feature vectors.

[0032] It should be noted that the entire model training process is performed locally; the original private data does not leave the domain, only the updated model parameters (after adjustment) are shared. Uploading data via PNN solves the problem of data silos. Compared to transmitting the entire model or a large amount of data, transmitting only the variable data (usually sparse or low-rank) greatly reduces network bandwidth overhead. Furthermore, the training starts with the general knowledge of the central server (global model + feature vectors), and incorporates local specific experience through local training, achieving a balance between generality and personalization. At the same time, the PNN model has a simple structure and fast training speed, making it suitable for edge computing with limited resources (such as monitor nodes in storage clusters).

[0033] Step 104: Send the model parameter update amount to the central server so that when the number of received model parameter update amounts is greater than or equal to the target threshold, the central server updates the global fault diagnosis model to be updated based on the received model parameter update amounts to obtain the target global fault diagnosis model.

[0034] In this embodiment of the application, the target threshold (M) refers to the minimum number of local updates that the central server needs to receive to start global model aggregation, and is a preset value (M≤N, where N is the total number of local servers); the target global fault diagnosis model refers to a new generation of global model with improved performance generated by the central server after collecting a sufficient number (≥M) of local updates by aggregating these updates (such as weighted average).

[0035] In this embodiment, the local server sends the calculated model parameter update to the central server. The central server does not wait for all local servers to respond. Instead, when the number of received updates reaches the target threshold M, it immediately performs aggregate updates on the global fault diagnosis model to be updated based on these updates, generating a new generation of target global fault diagnosis model. This can significantly reduce communication overhead and overall training time, and improve training efficiency and robustness. It should be noted that the local server only sends the model parameter update to the central server, rather than sending the original data (i.e., sample private data) to the central server, thereby protecting the data privacy of the local server.

[0036] The model training method provided in this application embodiment allows the local server to train the received global model to be updated using its private data and the initial feature vector set distributed by the central server. The local server then calculates the model parameter update amount and sends it back to the central server. In other words, the local server and the central server do not need to share sensitive original private data, but only exchange model parameter update amounts. This fundamentally protects data privacy and breaks down data barriers. At the same time, it allows the central server to perform global model optimization as soon as it receives a certain number of model parameter updates, without having to wait for all the model parameter updates sent by the local servers. This greatly alleviates the synchronization waiting problem caused by node heterogeneity and significantly improves training efficiency and response speed.

[0037] Based on the foregoing embodiments, this application provides a model training method applied to a central server. Referring to FIG3, it can be implemented in the following way: Step 201: Generate a global fault diagnosis model to be updated based on sample general data, and extract an initial feature vector set corresponding to each state category from the global fault diagnosis model to be updated.

[0038] In this embodiment, the sample general data refers to the publicly available or anonymized dataset used by the central server that does not involve the privacy of any specific user or cluster; the global fault diagnosis model to be updated refers to the initial fault diagnosis model trained by the central server based on the general data, specifically, this model can be a probabilistic neural network model; the initial feature vector set refers to the mathematical representation (vector) extracted from the global fault diagnosis model to be updated that can characterize the core patterns of each type of fault state (normal, permanent, intermittent, transient). The central server first uses the sample general data to train an initial global fault diagnosis model. Subsequently, it extracts feature vector sets representing the four types of states (normal, permanent fault, intermittent fault, transient fault) from this model. In this way, it provides a standardized fault mode definition based on extensive knowledge for all participants (i.e., local servers), ensuring a consistent starting point for subsequent distributed training and diagnosis.

[0039] Step 202: Send the global fault diagnosis model to be updated and the initial feature vector set to at least one local server so that each local server can train the global fault diagnosis model to be updated based on its own sample private data.

[0040] In this embodiment, the central server sends the generated global fault diagnosis model to be updated, along with the four initial feature vector sets extracted from the model, to each local server (such as the monitor node of each storage cluster) participating in federated learning.

[0041] Step 203: Receive the model parameter update amount of the target local fault diagnosis model relative to the global fault diagnosis model to be updated, sent by multiple local servers.

[0042] In this embodiment, the central server receives model parameter updates uploaded from various local servers. These updates reflect the personalized adjustments made to the global model by each local storage cluster based on its own operational data and fault experience. In this way, each participant only uploads the model parameter updates, and the original sensitive data is always kept locally, fundamentally solving the "data silo" problem and improving data security and privacy. At the same time, by receiving these updates, the central server can collect diverse local knowledge from different data distributions and scenarios, preparing diverse data for the evolution of the global model.

[0043] Step 204: When the number of received model parameter updates is greater than or equal to the target threshold, aggregate and update the global fault diagnosis model to be updated based on the received model parameter updates until the target global fault diagnosis model is obtained.

[0044] In this embodiment, aggregation update refers to the process by which the central server fuses multiple received local model parameter updates using a specific algorithm (such as weighted averaging) and applies the fusion result to the current global model, thereby generating a new version of the model that incorporates a wealth of local knowledge. The target global fault diagnosis model refers to a new generation of global fault diagnosis model with improved performance and richer knowledge after one or more rounds of "receive update-aggregate" cycles. The central server does not need to wait for all local servers to complete training and upload updates. Instead, it sets a target threshold M. Once the number of received valid model parameter updates reaches or exceeds M, it immediately triggers the aggregation operation. The central server uses these received updates to perform aggregation update (i.e., asynchronous update method) on the current global fault diagnosis model to be updated. This process is iterated until the model performance converges or reaches a predetermined number of rounds, ultimately obtaining the optimized target global fault diagnosis model.

[0045] The model training method provided in this application embodiment allows the local server to train the received global model to be updated using its private data and the initial feature vector set distributed by the central server. The local server then calculates the model parameter update amount and sends it back to the central server. In other words, the local server and the central server do not need to share sensitive original private data, but only exchange model parameter update amounts. This fundamentally protects data privacy and breaks down data barriers. At the same time, it allows the central server to perform global model optimization as soon as it receives a certain number of model parameter updates, without having to wait for all the model parameter updates sent by the local servers. This greatly alleviates the synchronization waiting problem caused by node heterogeneity and significantly improves training efficiency and response speed.

[0046] Based on the foregoing embodiments, this application also provides a fault detection method applied to a local server. Referring to FIG4, it can be implemented through the following steps: Step 301: Receive the set of target feature vectors corresponding to each state category extracted from the target global fault diagnosis model sent by the central server.

[0047] In this embodiment, the target global fault diagnosis model refers to the global model that finally converges or meets the performance requirements after multiple rounds of collaborative training between the central server and local servers (i.e., asynchronous federated learning process). Compared with the initial model, it integrates private data experience from multiple local servers, making it more robust and capable of diagnosis. The target feature vector set refers to the latest feature vector set extracted from the final target global fault diagnosis model, representing four types of states (normal state, permanent fault, intermittent fault, and transient fault). It is the essence of the fusion of global knowledge and numerous local experiences, representing the most accurate pattern definition of various faults by the current model.

[0048] In this embodiment of the application, after the federated learning training process is completed, the local server receives the set of target feature vectors extracted from the trained global target model from the central server.

[0049] Step 302: Collect the private data to be diagnosed from the data service node managed by the local server.

[0050] In this embodiment, the private data to be diagnosed refers to operational data collected in real-time or near real-time from the storage cluster managed by the local server, which requires status assessment. This data reflects the current status of the data service nodes and may contain signs of failure; therefore, it is also considered sensitive private data. The local server collects the latest operational metrics data (such as latency, error log counts, etc.) from the data service nodes it monitors (such as RGW, OSD) to form a sample of private data to be diagnosed, which serves as the input source for fault diagnosis.

[0051] Step 303: Using the target local fault diagnosis model and target feature vector set, perform fault detection on the private data to be diagnosed to obtain the target status category of the data service node.

[0052] In this embodiment, fault detection refers to the process of using a PNN model to calculate the probability of the data to be diagnosed belonging to each state category, and classifying it according to the principle of maximum probability. The local server uses its local fault diagnosis model, combined with the target feature vector set issued from the central server, to diagnose the collected private data to be diagnosed. Specifically, the data to be diagnosed is input into the PNN's pattern layer, and the formula is used... Calculate the data to be diagnosed (i.e.) ) and the target feature vector for each category (i.e. The Gaussian distance between the values ​​generates four probability density function (PDF) values ​​(which can be used to calculate the values ​​of the four values ​​of the probability density function (PDF)). (represented by the PDF values), indicating whether the data belongs to normal, permanent, intermittent, or transient faults, respectively. Finally, the category with the largest PDF value (i.e., As the final diagnostic result (target state category), The type is normal. This type is a permanent fault. This type is an intermittent fault. This type of fault is transient. It should be noted that the diagnostic process is entirely completed on the local server, without transmitting data out, ensuring minimal decision latency and absolute privacy and security. Furthermore, the model and feature vectors used are optimized through both federated learning and local adaptation, resulting in high diagnostic accuracy.

[0053] In one feasible implementation, for the collected data {latency: 150ms, error count: 5, CPU: 85%}, the PNN model will calculate the similarity (i.e., Gaussian distance) between the data and four sets of target feature vectors: "normal", "permanent", "intermittent", and "transient". If the calculated PDF values ​​are: F_normal=0.1, F_permanent=0.05, F_intermittent=0.7, F_transient=0.15, then, according to the principle of maximum probability, the data can be determined to belong to the intermittent failure category. Subsequently, this can be used to trigger early warning or processing procedures for intermittent failures.

[0054] It should be noted that the target local fault diagnosis model is trained in the following way: a1, receiving the global fault diagnosis model to be updated and the initial feature vector set corresponding to each state category sent by the central server.

[0055] The initial feature vector set is extracted from the global fault diagnosis model to be updated and represents the feature representation of various state modes; the state categories include normal state, permanent fault, intermittent fault and transient fault.

[0056] a2. Collect a set of private sample data from the local storage cluster of the local server.

[0057] a3. Based on the sample private data set and multiple initial feature vector sets, train the global fault diagnosis model to be updated to obtain the target local fault diagnosis model, and determine the model parameter update amount of the target local fault diagnosis model relative to the global fault diagnosis model to be updated.

[0058] Among them, the target local fault diagnosis model is used to detect faults in the data service nodes managed by the local server.

[0059] a4. Send the model parameter update amount to the central server so that when the number of received model parameter update amounts is greater than or equal to the target threshold, the central server updates the global fault diagnosis model to be updated based on the received model parameter update amounts to obtain the target global fault diagnosis model.

[0060] It should be noted that the target global fault diagnosis model is trained in the following way: b1. Generate the global fault diagnosis model to be updated based on the sample general data, and extract the initial feature vector set corresponding to each state category from the global fault diagnosis model to be updated.

[0061] b2. Send the global fault diagnosis model to be updated and the initial feature vector set to at least one local server so that each local server can train the global fault diagnosis model to be updated based on its own sample private data.

[0062] b3. Receive the model parameter update amount of the target local fault diagnosis model relative to the global fault diagnosis model to be updated, sent by multiple local servers.

[0063] b4. When the number of received model parameter updates is greater than or equal to the target threshold, aggregate and update the global fault diagnosis model to be updated based on the received model parameter updates until the target global fault diagnosis model is obtained.

[0064] The fault diagnosis method provided in this application embodiment uses the local server's private data and the initial feature vector set distributed by the central server to train the received global model to be updated, and calculates the model parameter update amount and sends it back to the central server. That is, the local server and the central server do not need to share sensitive original private data, but only exchange model parameter update amounts, which fundamentally protects data privacy and breaks down data barriers. At the same time, it allows the central server to perform global model optimization after receiving a certain number of model parameter updates, without having to wait to receive model parameter updates sent by all local servers. This greatly alleviates the synchronization waiting problem caused by node heterogeneity and significantly improves training efficiency and response speed.

[0065] Based on the foregoing embodiments, this application embodiment also provides another model training method, as shown in FIG5, which can be implemented through the following steps: Step 401: The central server generates a global fault diagnosis model to be updated based on the sample general data, and extracts an initial feature vector set corresponding to each state category from the global fault diagnosis model to be updated.

[0066] Step 402: The central server sends the global fault diagnosis model to be updated and the initial feature vector set to at least one local server, so that each local server can train the global fault diagnosis model to be updated based on its own sample private data.

[0067] Step 403: The local server receives the global fault diagnosis model to be updated and the initial feature vector set corresponding to each state category sent by the central server.

[0068] The initial feature vector set is extracted from the global fault diagnosis model to be updated and represents the feature representation of various state modes; the state categories include normal state, permanent fault, intermittent fault and transient fault.

[0069] Step 404: The local server collects a set of sample private data from the data service nodes managed by the local server.

[0070] Step 405: The local server uses a probabilistic neural network model to determine the probability density estimate of each sample private data belonging to each state category based on the sample private data set and feature vector set.

[0071] Both the global fault diagnosis model to be updated and the target local fault diagnosis model contain probabilistic neural network models.

[0072] In this embodiment, the probability density estimation uses a probabilistic neural network model to calculate the probability measure of whether a certain input data (such as a storage monitoring indicator) belongs to a specific state category (such as normal, permanent failure, etc.). This is a probability value; the larger the value, the higher the probability that the data belongs to that category. The local server uses its probabilistic neural network model to calculate the probability density estimate for each sample of private data collected, classifying it as belonging to one of the four categories: normal, permanent failure, intermittent failure, and transient failure. In one feasible implementation, if a local server collects a sample of private data {request latency: 200ms, packet loss rate: 0.1%}, this step can calculate the probability that this data belongs to one of the four categories: normal, permanent failure, intermittent failure, and transient failure, potentially yielding four estimates, such as [0.15, 0.05, 0.75, 0.05].

[0073] It should be noted that step 405 can be implemented in the following way: Step 405A, the local server determines the probability density estimate of each sample private data belonging to each state category based on the Gaussian function, the sample private data set and multiple initial feature vector sets.

[0074] Among them, the probabilistic neural network model is a probabilistic neural network model that uses a Gaussian function as the activation function.

[0075] In this embodiment, the Gaussian function (normal distribution function) is used as the activation function in the pattern layer of the PNN model. Its role is to map the distance between the input data and the feature vector to a similarity value; the closer the distance, the higher the output value of the Gaussian function (i.e., the higher the similarity). The local server's PNN model uses three elements—the Gaussian function, the private sample data set, and the initial feature vector set—to calculate the probability density. The PNN used employs a specific type that uses the Gaussian function as its pattern layer activation function. It should be noted that the Gaussian function effectively characterizes the distribution of data points in the feature space, making it particularly suitable for handling classification problems with potentially blurred class boundaries and complex patterns, such as storage failures. Furthermore, the similarity value output by the Gaussian function is continuous and smooth, making the final probability density estimate less sensitive to small fluctuations in the input data, resulting in a more robust model.

[0076] It should be noted that step 405A can also be implemented in the following way: Step 405a1, the local server calculates the distance between the private data of each sample and each feature vector in each initial feature vector set for each sample private data, and obtains multiple distance values.

[0077] In this embodiment, for each local private data sample that needs to be processed, the local server calculates the distance between it and each feature vector in each state category feature vector set. This distance is usually Euclidean distance, used to measure the proximity of the data point to a certain fault "pattern template" in the feature space. In one feasible implementation, for sample private data {latency: 200ms, packet loss rate: 0.1%}, if there is a vector in the intermittent fault class feature vector set with {latency: 180ms, packet loss rate: 0.2%}, then the Euclidean distance between them can be calculated, i.e., sqrt((200-180)²+(0.1-0.2)²).

[0078] Step 405a2: For each distance value, the local server uses a Gaussian function to transform the distance value to obtain the corresponding Gaussian function value.

[0079] In this embodiment, after obtaining the distance value, it is input into a Gaussian function for transformation (that is, mapping "distance" to "similarity" (Gaussian function value)). The Gaussian function has the following characteristics: when the distance is 0, the output value is a maximum of 1; the larger the distance, the smaller the output value and the closer it is to 0. It should be noted that through the nonlinear transformation of the Gaussian function, the model can more finely distinguish the similarity differences brought about by different distances.

[0080] Step 405a3: For each state category, the local server obtains a probability density estimate of whether the sample private data belongs to the state category based on multiple Gaussian function values ​​corresponding to the state category.

[0081] In this embodiment of the application, for each state category, all Gaussian function values ​​corresponding to the state category can be summed first, and then the total Gaussian function value obtained after summing can be normalized to obtain the probability density estimate of the sample private data belonging to the state category.

[0082] It should be noted that step 405a3 can also be implemented in the following way: S1, the local server sums up the multiple Gaussian function values ​​corresponding to each state category to obtain the total Gaussian function value of the state category.

[0083] S2. The local server normalizes the total Gaussian function value to obtain the probability density estimate.

[0084] In this embodiment, for a specific state category (such as intermittent fault), the Gaussian function values ​​calculated from the private data to be diagnosed and all feature vectors under that state category are summed. This total Gaussian function value reflects the comprehensive similarity between the data point and the overall pattern of the fault category. Then, in the summation layer of the PNN, the total Gaussian function value can be normalized (e.g., divided by the number of feature vectors k of the fault category, and considering the parameters of the Gaussian function), which can be expressed as... Finally, the probability density estimate of the private data of the sample belonging to the fault category is obtained. It should be noted that by summing the similarity of multiple feature prototypes (vectors) within a category, the model can comprehensively consider multiple manifestations of a fault mode, avoid misjudgment due to mismatch of a single prototype, improve the robustness of classification, and the final output probability density estimate makes the probability of different fault categories intuitively comparable.

[0085] In one feasible implementation, if the Gaussian function values ​​calculated from the private data of a sample and the three feature vectors of the intermittent fault class are [0.8, 0.6, 0.4], the sum is first calculated as: 0.8 + 0.6 + 0.4 = 1.8, and then normalized. After processing, the probability density estimate of the intermittent fault is finally obtained, such as 0.75.

[0086] Step 406: The local server adjusts the parameters of the global fault diagnosis model to be updated based on probability density estimation to obtain the target local fault diagnosis model.

[0087] Among them, the target local fault diagnosis model is used to detect faults in the data service nodes managed by the local server.

[0088] In this embodiment, after completing the probability density estimation calculation, the local server does not merely output the classification results, but uses these calculation results as supervision signals to optimize the internal parameters of the currently held global fault diagnosis model to be updated. For example, if the private sample data matches a certain type of fault feature more frequently, or if the characteristics of the data distribution make the original global smoothing parameters... If it's not optimal, the local training process will... Fine-tuning parameters aims to enable the model to calculate more accurate and confident probability density estimates when dealing with private sample data, thereby improving classification accuracy. After tuning, a personalized adaptation is achieved, enhancing diagnostic accuracy: this is a concrete manifestation of the local value of federated learning. Through fine-tuning, the model can better fit the statistical distribution of local data and is more sensitive to common local fault modes, thus significantly improving fault detection accuracy in that specific environment.

[0089] It should be noted that all adjustment calculations are completed locally, and the original private data does not need to leave the local machine. What is shared with the central server is only the condensed model parameter update amount after adjustment, not the data itself, which solves the data silo problem. Furthermore, the complex model iteration and adaptation calculations are distributed across various local servers, and the central server only needs to perform lightweight model aggregation, which achieves reasonable distribution of computing load.

[0090] Step 407: The local server determines the amount of model parameter update for the target local fault diagnosis model relative to the global fault diagnosis model to be updated.

[0091] Step 408: The local server sends the model parameter update amount to the central server, so that when the number of received model parameter update amounts is greater than or equal to the target threshold, the central server updates the global fault diagnosis model to be updated based on the received model parameter update amounts to obtain the target global fault diagnosis model.

[0092] Step 409: The central server receives the model parameter update amount of the target local fault diagnosis model relative to the global fault diagnosis model to be updated, sent by multiple local servers.

[0093] Step 410: When the number of received model parameter updates is greater than or equal to the target threshold, the central server performs aggregated updates on the global fault diagnosis model to be updated based on the received model parameter updates until the target global fault diagnosis model is obtained.

[0094] It should be noted that this application 1. combines general-purpose storage architecture with federated learning, utilizing the existing resource advantages of general-purpose storage to train local models; 2. combines PNN models with federated learning, with the central server extracting feature vectors and then distributing them to local servers for subsequent training and fault diagnosis; 3. adopts an asynchronous update method to accelerate global model aggregation, thereby ensuring data security and rational resource utilization while achieving fault diagnosis. Furthermore, the asynchronous update method accelerates global model aggregation, significantly reducing communication overhead and training time.

[0095] It should be noted that the descriptions of the same steps and contents as in other embodiments in this embodiment can be found in the descriptions in other embodiments, and will not be repeated here.

[0096] The model training method provided in the embodiments of this application allows the local server to train the received global model to be updated using its private data and the initial feature vector set distributed by the central server. The local server then calculates the model parameter update and sends it back to the central server. In other words, the local server and the central server do not need to share sensitive original private data, but only exchange model parameter update amounts. This fundamentally protects data privacy and breaks down data barriers. At the same time, it allows the central server to perform global model optimization as soon as it receives a certain number of model parameter updates, without having to wait for all the model parameter updates sent by the local servers. This greatly alleviates the synchronization waiting problem caused by node heterogeneity and significantly improves training efficiency and response speed.

[0097] Based on the foregoing embodiments, this application provides a first model training device, which can be applied to the model training methods provided in the embodiments corresponding to FIG1 and FIG5. Referring to FIG6, the first model training device 5 may include: a first receiving unit 51, a first acquiring unit 52, a first training unit 53, and a first sending unit 54, wherein: the first receiving unit 51 is used to receive the global fault diagnosis model to be updated and the initial feature vector set corresponding to each state category sent by the central server; wherein, the initial feature vector set is extracted from the global fault diagnosis model to be updated and represents the feature representation of various state modes; the state categories include normal state, permanent fault, intermittent fault, and transient fault; the first acquiring unit 52 is used to obtain data from the local server... The system collects a set of sample private data from the data service nodes managed by the server; the first training unit 53 is used to train the global fault diagnosis model to be updated based on the sample private data set and multiple initial feature vector sets to obtain a target local fault diagnosis model, and to determine the model parameter update amount of the target local fault diagnosis model relative to the global fault diagnosis model to be updated; wherein, the target local fault diagnosis model is used to perform fault detection on the data service nodes managed by the local server; the first sending unit 54 is used to send the model parameter update amount to the central server, so that when the number of received model parameter update amounts is greater than or equal to the target threshold, the central server updates the global fault diagnosis model to be updated based on the received model parameter update amounts to obtain the target global fault diagnosis model.

[0098] In other embodiments of this application, the first training unit 53 is further configured to perform the following steps: using a probabilistic neural network model, based on the sample private data set and the feature vector set, to determine the probability density estimate of each sample private data belonging to each state category; wherein, both the global fault diagnosis model to be updated and the target local fault diagnosis model contain a probabilistic neural network model; and adjusting the parameters of the global fault diagnosis model to be updated based on the probability density estimate to obtain the target local fault diagnosis model.

[0099] In other embodiments of this application, the first training unit 53 is further configured to perform the following steps: based on a Gaussian function, a set of sample private data, and multiple sets of initial feature vectors, determine the probability density estimate of each sample private data belonging to each state category; wherein, the probabilistic neural network model is a probabilistic neural network model that uses a Gaussian function as the activation function.

[0100] In other embodiments of this application, the first training unit 53 is further configured to perform the following steps: for each sample private data, calculate the distance between the sample private data and each feature vector in each initial feature vector set to obtain multiple distance values; for each distance value, use a Gaussian function to transform the distance value to obtain the Gaussian function value corresponding to the distance value; for each state category, based on the multiple Gaussian function values ​​corresponding to the state category, obtain a probability density estimate of the sample private data belonging to the state category.

[0101] In other embodiments of this application, the first training unit 53 is further configured to perform the following steps: for each state category, summing the multiple Gaussian function values ​​corresponding to the state category to obtain the total Gaussian function value of the state category; and normalizing the total Gaussian function value to obtain a probability density estimate.

[0102] It should be noted that the specific details of the steps performed by each unit can be found in the model training methods provided in the embodiments corresponding to Figures 1 and 5, and will not be repeated here.

[0103] The first model training apparatus provided in the embodiments of this application allows the local server to train the received global model to be updated using its private data and the initial feature vector set distributed by the central server, and to calculate the model parameter update amount and send it back to the central server. That is, the local server and the central server do not need to share sensitive original private data, but only exchange model parameter update amounts, which fundamentally protects data privacy and breaks down data barriers. At the same time, it allows the central server to perform global model optimization as soon as it receives a certain number of model parameter updates, without having to wait to receive model parameter updates sent by all local servers. This greatly alleviates the synchronization waiting problem caused by node heterogeneity and significantly improves training efficiency and response speed.

[0104] Based on the foregoing embodiments, this application provides a second model training device, which can be applied to the model training methods provided in the embodiments corresponding to FIG3 and FIG5. Referring to FIG7, the second model training device 6 may include: a first determining unit 61, a second sending unit 62, a second receiving unit 63, and a second training unit 64, wherein: the first determining unit 61 is used to generate a global fault diagnosis model to be updated based on sample general data, and extract an initial feature vector set corresponding to each state category from the global fault diagnosis model to be updated; the second sending unit 62 is used to send the global fault diagnosis model to be updated and the initial feature vector set to at least one local server, so that each local server trains the global fault diagnosis model to be updated based on its own sample private data; the second receiving unit 63 is used to receive the model parameter update amount of the target local fault diagnosis model relative to the global fault diagnosis model to be updated sent by multiple local servers; the second training unit 64 is used to aggregate and update the global fault diagnosis model to be updated based on the received model parameter update amount when the number of received model parameter update amounts is greater than or equal to a target threshold, until the target global fault diagnosis model is obtained.

[0105] It should be noted that the specific details of the steps performed by each unit can be found in the model training methods provided in the embodiments corresponding to Figures 3 and 5, and will not be repeated here.

[0106] The second model training apparatus provided in this application embodiment allows the local server to train the received global model to be updated using its private data and the initial feature vector set distributed by the central server. The local server then calculates the model parameter update amount and sends it back to the central server. In other words, the local server and the central server do not need to share sensitive original private data, but only exchange model parameter update amounts, which fundamentally protects data privacy and breaks down data barriers. At the same time, it allows the central server to perform global model optimization as soon as it receives a certain number of model parameter updates, without having to wait to receive model parameter updates from all local servers. This greatly alleviates the synchronization waiting problem caused by node heterogeneity and significantly improves training efficiency and response speed.

[0107] Based on the foregoing embodiments, this application provides a fault detection device that can be applied to the model training method provided in the embodiment corresponding to FIG4. Referring to FIG8, the fault detection device 7 may include: a third receiving unit 71, a second acquiring unit 72, and a second determining unit 73, wherein: the third receiving unit 71 is used to receive a set of target feature vectors corresponding to each state category extracted from the target global fault diagnosis model sent by the central server; the second acquiring unit 72 is used to collect private data to be diagnosed from the data service nodes managed by the local server; the second determining unit 73 is used to perform fault detection on the private data to be diagnosed using the target local fault diagnosis model and the set of target feature vectors to obtain the target state category of the data service node; wherein, the target local fault diagnosis model is trained in the following manner: receiving the global fault diagnosis model to be updated and the initial set of feature vectors corresponding to each state category sent by the central server.

[0108] The initial feature vector set is extracted from the global fault diagnosis model to be updated and represents the feature representation of various state modes; the state categories include normal state, permanent fault, intermittent fault and transient fault.

[0109] Collect a private dataset of samples from the data service nodes managed by the local server.

[0110] Based on the sample private data set and multiple initial feature vector sets, the global fault diagnosis model to be updated is trained to obtain the target local fault diagnosis model, and the model parameter update amount of the target local fault diagnosis model relative to the global fault diagnosis model to be updated is determined; wherein, the target local fault diagnosis model is used to detect faults in the data service nodes managed by the local server.

[0111] The model parameter update amount is sent to the central server so that when the number of received model parameter update amounts is greater than or equal to the target threshold, the central server updates the global fault diagnosis model to be updated based on the received model parameter update amounts to obtain the target global fault diagnosis model.

[0112] The target global fault diagnosis model is trained in the following way: a global fault diagnosis model to be updated is generated based on the sample general data, and an initial feature vector set corresponding to each state category is extracted from the global fault diagnosis model to be updated.

[0113] Send the global fault diagnosis model to be updated and the initial feature vector set to at least one local server so that each local server can train the global fault diagnosis model to be updated based on its own sample private data.

[0114] Receive the model parameter update amount of the target local fault diagnosis model relative to the global fault diagnosis model to be updated from multiple local servers.

[0115] When the number of received model parameter updates is greater than or equal to the target threshold, the global fault diagnosis model to be updated is aggregated and updated based on the received model parameter updates until the target global fault diagnosis model is obtained.

[0116] It should be noted that the specific description of the steps performed by each unit can be found in the fault detection method provided in the corresponding embodiment of Figure 4, and will not be repeated here.

[0117] The fault detection device provided in the embodiments of this application allows the local server to use its private data and the initial feature vector set distributed by the central server to train the received global model to be updated, and calculate the model parameter update amount and send it back to the central server. That is, the local server and the central server do not need to share sensitive original private data, but only exchange model parameter update amounts, which fundamentally protects data privacy and breaks down data barriers. At the same time, it allows the central server to perform global model optimization after receiving a certain number of model parameter updates, without having to wait to receive model parameter updates sent by all local servers. This greatly alleviates the synchronization waiting problem caused by node heterogeneity and significantly improves training efficiency and response speed.

[0118] Based on the foregoing embodiments, this application provides a local server that can be applied to the model training methods provided in the embodiments corresponding to Figures 1 and 5. Referring to Figure 9, the local server 8 may include: a first processor 81, a first memory 82, and a first communication bus 83, wherein: the first communication bus 83 is used to establish a communication connection between the first processor 81 and the first memory 82; the first processor 81 is used to execute the model training program in the first memory 82 to implement the following steps: receiving the global fault diagnosis model to be updated and the initial feature vector set corresponding to each state category sent by the central server; wherein, the initial feature vector set is extracted from the global fault diagnosis model to be updated and represents the feature representation of various state patterns; state categories The process includes identifying normal, permanent, intermittent, and transient faults. A set of sample private data is collected from data service nodes managed by the local server. Based on this sample private data set and multiple initial feature vector sets, the global fault diagnosis model to be updated is trained to obtain a target local fault diagnosis model, and the model parameter update amount of the target local fault diagnosis model relative to the global fault diagnosis model to be updated is determined. The target local fault diagnosis model is used to detect faults in the data service nodes managed by the local server. The model parameter update amount is sent to the central server, so that when the number of received model parameter updates is greater than or equal to a target threshold, the central server updates the global fault diagnosis model to be updated based on the received model parameter update amount to obtain the target global fault diagnosis model.

[0119] In other embodiments of this application, the first processor 81 is used to execute a model training program in the first memory 82 based on a set of sample private data and multiple initial feature vector sets to train the global fault diagnosis model to be updated, thereby obtaining a target local fault diagnosis model, to achieve the following steps: using a probabilistic neural network model, based on the set of sample private data and the feature vector sets, to determine the probability density estimate of each sample private data belonging to each state category; wherein, both the global fault diagnosis model to be updated and the target local fault diagnosis model contain a probabilistic neural network model; and adjusting the parameters of the global fault diagnosis model to be updated based on the probability density estimate to obtain the target local fault diagnosis model.

[0120] In other embodiments of this application, the first processor 81 is used to execute the model training program in the first memory 82 using a probabilistic neural network model, and to determine the probability density estimate of each sample private data belonging to each state category based on the sample private data set and the feature vector set, in order to achieve the following steps: determining the probability density estimate of each sample private data belonging to each state category based on a Gaussian function, the sample private data set and multiple initial feature vector sets; wherein, the probabilistic neural network model is a probabilistic neural network model using a Gaussian function as the activation function.

[0121] In other embodiments of this application, the first processor 81 is used to execute the model training program in the first memory 82 based on a Gaussian function, a set of sample private data, and multiple sets of initial feature vectors to determine the probability density estimate of each sample private data belonging to each state category, in order to implement the following steps: for each sample private data, calculate the distance between the sample private data and each feature vector in each set of initial feature vectors to obtain multiple distance values; for each distance value, use a Gaussian function to transform the distance value to obtain the Gaussian function value corresponding to the distance value; for each state category, based on the multiple Gaussian function values ​​corresponding to the state category, obtain the probability density estimate of the sample private data belonging to the state category.

[0122] In other embodiments of this application, the first processor 81 is used to execute the model training program in the first memory 82 based on multiple Gaussian function values ​​corresponding to the state category to obtain a probability density estimate of the sample private data belonging to the state category, so as to achieve the following steps: for each state category, summing multiple Gaussian function values ​​corresponding to the state category to obtain the total Gaussian function value of the state category; normalizing the total Gaussian function value to obtain the probability density estimate.

[0123] It should be noted that the specific details of the steps performed by the first processor can be found in the model training methods provided in the embodiments corresponding to Figures 1 and 5, and will not be repeated here.

[0124] The local server provided in the embodiments of this application uses its private data and the initial feature vector set distributed by the central server to train the received global model to be updated, and calculates the model parameter update amount and sends it back to the central server. That is, the local server and the central server do not need to share sensitive original private data, but only exchange model parameter update amounts, which fundamentally protects data privacy and breaks down data barriers. At the same time, it allows the central server to perform global model optimization after receiving a certain number of model parameter updates, without having to wait to receive model parameter updates sent by all local servers. This greatly alleviates the synchronization waiting problem caused by node heterogeneity and significantly improves training efficiency and response speed.

[0125] Based on the foregoing embodiments, the embodiments of this application provide a central server that can be applied to the model training method provided in the embodiments corresponding to Figures 3 and 5. Referring to Figure 10, the central server 9 may include: a second processor 91, a second memory 92, and a second communication bus 93, wherein: the second communication bus 93 is used to realize the communication connection between the second processor 91 and the second memory 92; the second processor 91 is used to execute the model training program in the second memory 92 to implement the following steps: generating a global fault diagnosis model to be updated based on sample general data, and extracting an initial feature vector set corresponding to each state category from the global fault diagnosis model to be updated; sending the global fault diagnosis model to be updated and the initial feature vector set to at least one local server, so that each local server trains the global fault diagnosis model to be updated based on its own sample private data; receiving the model parameter update amount of the target local fault diagnosis model relative to the global fault diagnosis model to be updated sent by multiple local servers; when the number of received model parameter update amounts is greater than or equal to a target threshold, performing aggregated updates on the global fault diagnosis model to be updated based on the received model parameter update amounts, until the target global fault diagnosis model is obtained.

[0126] It should be noted that the specific details of the steps performed by the first processor can be found in the model training methods provided in the embodiments corresponding to Figures 3 and 5, and will not be repeated here.

[0127] The second model training device provided in the embodiments of this application allows the local server to train the received global model to be updated using its private data and the initial feature vector set distributed by the central server. The local server calculates the model parameter update and sends it back to the central server. That is, the local server and the central server do not need to share sensitive original private data, but only exchange model parameter update amounts, which fundamentally protects data privacy and breaks down data barriers. At the same time, it allows the central server to perform global model optimization as soon as it receives a certain number of model parameter updates, without having to wait to receive model parameter updates from all local servers. This greatly alleviates the synchronization waiting problem caused by node heterogeneity and significantly improves training efficiency and response speed.

[0128] Based on the foregoing embodiments, this application provides a fault detection device that can be applied to the fault detection method provided in the embodiment corresponding to FIG4. Referring to FIG11, the fault detection device 10 may include: a third processor 101, a third memory 102, and a third communication bus 103, wherein: the third communication bus 103 is used to realize the communication connection between the third processor 101 and the third memory 102; the third processor 101 is used to execute the model training program in the third memory 102 to implement the following steps: receiving a set of target feature vectors corresponding to each state category extracted from the target global fault diagnosis model sent by the central server; collecting private data to be diagnosed from the data service node managed by the local server; using the target local fault diagnosis model and the set of target feature vectors to perform fault detection on the private data to be diagnosed, and obtaining the target state category of the data service node; wherein, the target local fault diagnosis model is trained in the following manner: receiving the global fault diagnosis model to be updated and the initial set of feature vectors corresponding to each state category sent by the central server.

[0129] The initial feature vector set is extracted from the global fault diagnosis model to be updated and represents the feature representation of various state modes; the state categories include normal state, permanent fault, intermittent fault and transient fault.

[0130] Collect a private dataset of samples from the data service nodes managed by the local server.

[0131] Based on the sample private data set and multiple initial feature vector sets, the global fault diagnosis model to be updated is trained to obtain the target local fault diagnosis model, and the model parameter update amount of the target local fault diagnosis model relative to the global fault diagnosis model to be updated is determined; wherein, the target local fault diagnosis model is used to detect faults in the data service nodes managed by the local server.

[0132] The model parameter update amount is sent to the central server so that when the number of received model parameter update amounts is greater than or equal to the target threshold, the central server updates the global fault diagnosis model to be updated based on the received model parameter update amounts to obtain the target global fault diagnosis model.

[0133] The target global fault diagnosis model is trained in the following way: a global fault diagnosis model to be updated is generated based on the sample general data, and an initial feature vector set corresponding to each state category is extracted from the global fault diagnosis model to be updated.

[0134] Send the global fault diagnosis model to be updated and the initial feature vector set to at least one local server so that each local server can train the global fault diagnosis model to be updated based on its own sample private data.

[0135] Receive the model parameter update amount of the target local fault diagnosis model relative to the global fault diagnosis model to be updated from multiple local servers.

[0136] When the number of received model parameter updates is greater than or equal to the target threshold, the global fault diagnosis model to be updated is aggregated and updated based on the received model parameter updates until the target global fault diagnosis model is obtained.

[0137] It should be noted that the specific details of the steps performed by the first processor can be found in the model training method provided in the corresponding embodiment of Figure 4, and will not be repeated here.

[0138] The local server provided in the embodiments of this application uses its private data and the initial feature vector set distributed by the central server to train the received global model to be updated, and calculates the model parameter update amount and sends it back to the central server. That is, the local server and the central server do not need to share sensitive original private data, but only exchange model parameter update amounts, which fundamentally protects data privacy and breaks down data barriers. At the same time, it allows the central server to perform global model optimization after receiving a certain number of model parameter updates, without having to wait to receive model parameter updates sent by all local servers. This greatly alleviates the synchronization waiting problem caused by node heterogeneity and significantly improves training efficiency and response speed.

[0139] Based on the foregoing embodiments, this application provides a computer program product, including a computer program that, when executed by a processor, implements the steps in the model training method provided in the embodiments corresponding to Figures 1, 3, and 5, or the fault detection method provided in the embodiment corresponding to Figure 4.

[0140] Based on the foregoing embodiments, this application provides a computer-readable storage medium storing one or more programs that can be executed by one or more processors to implement the steps in the model training method provided in the embodiments corresponding to FIG1, FIG3 and FIG5 or the fault detection method provided in the embodiment corresponding to FIG4.

[0141] The above description is merely an embodiment of this application and is not intended to limit the scope of protection of this application. Any modifications, equivalent substitutions, and improvements made within the spirit and scope of this application are included within the scope of protection of this application.

Claims

1. A model training method, characterized in that, The method, applied to a local server, includes: receiving a global fault diagnosis model to be updated and an initial feature vector set corresponding to each state category from a central server; wherein the initial feature vector set is extracted from the global fault diagnosis model to be updated and represents the feature representation of various state modes; the state categories include normal state, permanent fault, intermittent fault, and transient fault; collecting a sample private data set from data service nodes managed by the local server; training the global fault diagnosis model to be updated based on the sample private data set and multiple initial feature vector sets to obtain a target local fault diagnosis model, and determining the model parameter update amount of the target local fault diagnosis model relative to the global fault diagnosis model to be updated; wherein the target local fault diagnosis model is used to detect faults in the data service nodes; sending the model parameter update amount to the central server, so that when the number of received model parameter update amounts is greater than or equal to a target threshold, the central server updates the global fault diagnosis model to be updated based on the received model parameter update amounts to obtain the target global fault diagnosis model.

2. The method according to claim 1, characterized in that, The step of training the global fault diagnosis model to be updated based on the sample private data set and multiple initial feature vector sets to obtain a target local fault diagnosis model includes: using a probabilistic neural network model, determining the probability density estimate of each sample private data belonging to each state category based on the sample private data set and the feature vector sets; wherein both the global fault diagnosis model to be updated and the target local fault diagnosis model include the probabilistic neural network model; and adjusting the parameters of the global fault diagnosis model to be updated based on the probability density estimate to obtain the target local fault diagnosis model.

3. The method according to claim 2, characterized in that, The method of employing a probabilistic neural network model to determine the probability density estimate of each sample private data belonging to each state category based on the sample private data set and the feature vector set includes: determining the probability density estimate of each sample private data belonging to each state category based on a Gaussian function, the sample private data set, and multiple initial feature vector sets; wherein, the probabilistic neural network model is a probabilistic neural network model that uses the Gaussian function as the activation function.

4. The method according to claim 3, characterized in that, The step of determining the probability density estimate of each sample private data belonging to each state category based on a Gaussian function, the sample private data set, and multiple initial feature vector sets includes: for each sample private data, calculating the distance between the sample private data and each feature vector in each initial feature vector set to obtain multiple distance values; for each distance value, transforming the distance value using a Gaussian function to obtain the Gaussian function value corresponding to the distance value; and for each state category, obtaining the probability density estimate of the sample private data belonging to the state category based on the multiple Gaussian function values ​​corresponding to the state category.

5. The method according to claim 4, characterized in that, The step of obtaining the probability density estimate of the sample private data belonging to the state category based on the multiple Gaussian function values ​​corresponding to the state category includes: for each state category, summing the multiple Gaussian function values ​​corresponding to the state category to obtain the total Gaussian function value of the state category; and normalizing the total Gaussian function value to obtain the probability density estimate.

6. A model training method, characterized in that, The method, applied to a central server, includes: generating a global fault diagnosis model to be updated based on sample general data, and extracting an initial feature vector set corresponding to each state category from the global fault diagnosis model to be updated; sending the global fault diagnosis model to be updated and the initial feature vector set to at least one local server, so that each local server trains the global fault diagnosis model to be updated based on its own sample private data; receiving model parameter update amounts of a target local fault diagnosis model relative to the global fault diagnosis model to be updated sent by multiple local servers; and when the number of received model parameter update amounts is greater than or equal to a target threshold, performing aggregated updates on the global fault diagnosis model to be updated based on the received model parameter update amounts until a target global fault diagnosis model is obtained.

7. A fault detection method, characterized in that, Applied to a local server, the method further includes: receiving a set of target feature vectors corresponding to each state category extracted from the target global fault diagnosis model, sent by a central server; collecting private data to be diagnosed from the data service nodes managed by the local server; and performing fault detection on the private data to be diagnosed using the target local fault diagnosis model and the set of target feature vectors to obtain the target state category of the data service node; wherein the target local fault diagnosis model is trained using the model training method described in any one of claims 1 to 5; and the target global fault diagnosis model is trained using the model training method described in claim 6.

8. A fault detection device, characterized in that, The device includes: a memory for storing computer-executable instructions or computer programs; and a processor for executing the computer-executable instructions or computer programs stored in the memory to implement the method according to any one of claims 1 to 5, 6, or 7.

9. A computer program product, comprising a computer program, characterized in that, When the computer program is executed by a processor, it implements the method according to any one of claims 1 to 5, 6 or 7.

10. A computer-readable storage medium, characterized in that, The computer-readable storage medium stores one or more programs, which can be executed by one or more processors to implement the method of any one of claims 1 to 5, 6 or 7.

Images