Privacy computing method for sharing of vehicle networking diagnosis data

Abstract

The application discloses a kind of privacy computing's vehicle networking diagnostic data sharing method, original diagnostic data is split into multiple secret fragments by secret sharing algorithm and is distributed to different edge computing nodes by the vehicle terminal of the application, so that any node cannot independently restore complete data, each edge computing node cooperates to execute gradient calculation based on secure multi-party computation protocol in the form of secret fragment, realizes the complete concealment of data content in the calculation stage, and the center aggregation server only collects the intermediate fragment reaching threshold number to reconstruct the model parameter after aggregation, rather than the original data of any vehicle, forms a safe training closed loop through dynamic iterative update mechanism, resists model back-propagation attack through differential privacy noise injection, reduces communication overhead through model parameter pruning and quantization, and the vehicle terminal uses global model parameter to infer in real time without uploading data, so that low-delay and privacy-compliant fault diagnosis is realized.

Description

Technical Field

[0001] This application relates to the field of computer networks and information security, specifically to a privacy-computing method for sharing diagnostic data in vehicle networks. Background Technology

[0002] With the popularization of vehicle-to-everything (V2X) technology, real-time diagnostic data generated by vehicles during operation is increasingly becoming digital assets with significant application value. Diagnostic data such as vehicle status parameters, component fault codes, and controller area network bus data have important data element value for automobile manufacturers' product improvement and fault early warning, service providers' precise maintenance, insurance companies' development of usage-based insurance models, and traffic management departments' traffic condition optimization.

[0003] However, existing data sharing methods based on traditional encryption require data to be decrypted into plaintext before it can be processed by the computing party when collaborative computation of diagnostic data is needed. This results in the original diagnostic data being exposed to the computing party during the computation process, failing to meet the requirement of data being usable but not visible. Summary of the Invention

[0004] The purpose of this application is to provide a privacy-preserving computation method for sharing vehicle network diagnostic data, so as to at least solve some of the problems mentioned in the background art.

[0005] According to one aspect of this application, a method for sharing vehicle-to-everything (V2X) diagnostic data through privacy computing is provided, comprising the following steps:

[0006] S1. The vehicle terminal collects the original diagnostic data of the vehicle, preprocesses the original diagnostic data to obtain structured feature data, and splits the structured feature data into multiple first secret fragments based on the secret sharing algorithm, and sends each first secret fragment to at least two edge computing nodes respectively.

[0007] S2. The central aggregation server publishes joint computing tasks based on the edge computing nodes that have received the first secret fragment. The edge computing nodes execute a secure multi-party computation protocol based on the first secret fragments received from different vehicle terminals to obtain intermediate computing result fragments corresponding to the joint computing tasks.

[0008] S3. The central aggregation server collects intermediate computing result fragments from a preset number of edge computing nodes and recovers the complete intermediate computing results based on a secret-sharing reconstruction algorithm.

[0009] S4. The central aggregation server updates the global diagnostic model based on the complete intermediate calculation results, obtains the updated global diagnostic model parameters, and sends the updated global diagnostic model parameters to the vehicle terminal.

[0010] S5. The vehicle terminal uses the received global diagnostic model parameters to configure the local diagnostic model and performs diagnostic analysis on the local data.

[0011] Preferably, the structured feature data is split into multiple first secret fragments based on a secret sharing algorithm, including the following steps:

[0012] S111, the vehicle terminal identifies the structured feature data as the secret S to be shared;

[0013] S112, The vehicle terminal constructs a random polynomial, where the constant term is a secret S;

[0014] S113, the vehicle terminal assigns a unique public identifier x_i to each target edge computing node, and substitutes the public identifier x_i into a polynomial to determine the corresponding function value y_i, where the (x_i, y_i) pair constitutes the first secret fragment sent to the i-th edge computing node.

[0015] Preferably, the random polynomial is a polynomial of order t-1, where t is the minimum number of shards required to reconstruct the secret, and t is not greater than the total number of edge computing nodes.

[0016] Preferably, the preset number in S3 is not less than the minimum number of fragments required to reconstruct the secret, threshold t.

[0017] Preferably, in step S2, the joint computation task is a federated learning model training task, which includes the following steps:

[0018] S21. Each edge computing node uses the first secret shard stored locally to collaboratively compute the model parameter update amount of this round of federated learning in the form of secret shards based on the secure multi-party computation protocol, and obtains the model parameter update amount shard.

[0019] S22. Each edge computing node safely adds the previously stored global model parameter fragments and model parameter update fragments to obtain the updated global model parameter fragments. The updated global model parameter fragments form the intermediate computing result fragments.

[0020] Preferably, in step S21, the gradient of the loss function of the federated learning model with respect to the model parameters is calculated based on the secure multi-party computation protocol, and gradient slices are obtained.

[0021] Preferably, a secure multiplication protocol based on secret sharing pre-distributes triples to each edge computing node. The edge computing nodes use the pre-distributed triples to shard locally, exchange the masked shard information, and collaboratively calculate the result shard corresponding to the product of the two secret shards.

[0022] Preferably, in step S1, the original diagnostic data is preprocessed to obtain structured feature data, including the following steps:

[0023] S121, raw data stream is collected from the vehicle bus network, the raw data stream includes the controller area network message sequence;

[0024] S122, parse and clean the raw data stream, and extract the timing data of multiple preset signal channels;

[0025] S123 divides the time series data into fixed time windows and encodes them into a fixed-dimensional feature matrix to obtain structured feature data.

[0026] Preferably, in step S123, the feature matrix encoded as a fixed-dimensional matrix includes any of the following: Statistical features are extracted from signal values ​​within the time window; time series data are converted into a grayscale matrix.

[0027] Preferably, the following steps are also included: S41, The central aggregation server determines whether the updated global diagnostic model parameters meet the model convergence conditions; S42, if satisfied, then the updated global diagnostic model parameters will be used as the final global diagnostic model parameters; S43. If not satisfied, the central aggregation server will re-split the updated global diagnostic model parameters into multiple second secret fragments and distribute them to each edge computing node. Each edge computing node will use the second secret fragments to replace the previously stored global model parameter fragments and start the next round of joint computing tasks.

[0028] This application addresses the technical bottleneck in existing vehicle-to-everything (V2X) diagnostic data sharing methods. Traditional encryption schemes require decryption of ciphertext into plaintext during the computation phase, resulting in the complete exposure of the original diagnostic data on the computation side. This fails to meet the core security requirement of keeping data content confidential during collaborative computation. By jointly designing multiple technical means such as secret sharing splitting, secure multi-party computation collaboration, and federated learning iterative updates, this application achieves multi-party collaborative computation and model training without leaking the original diagnostic data, effectively releasing the potential value of V2X diagnostic data elements.

[0029] Specifically, in this application, the vehicle terminal uses a secret sharing algorithm to split the original diagnostic data into multiple secret fragments and distribute them to different edge computing nodes, making it impossible for any single node to independently recover the complete data. Each edge computing node collaboratively performs gradient calculations in the form of secret fragments based on a secure multi-party computation protocol, achieving complete concealment of the data content during the calculation phase. The central aggregation server only collects the model parameters after reconstructing and aggregating the intermediate fragments up to a threshold number, rather than the original data of any vehicle. A secure training closed loop is formed through a dynamic iterative update mechanism, and differential privacy noise injection is used to resist model back-inference attacks. Communication overhead is reduced through model parameter pruning and quantization. The vehicle terminal uses global model parameters for real-time inference without uploading data, thereby achieving low-latency and privacy-compliant fault diagnosis. Attached Figure Description

[0030] Figure 1 This is a block diagram of a privacy-computing method for sharing vehicle-to-everything (V2X) diagnostic data according to an embodiment of this application. Detailed Implementation

[0031] The technical solutions of the embodiments of this application will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are only some embodiments of this application, and not all embodiments. Based on the embodiments of this application, all other embodiments obtained by those skilled in the art without creative effort are within the scope of protection of this application.

[0032] Please see Figure 1 According to one embodiment of this application, a method for sharing vehicle network diagnostic data with privacy-preserving computation is provided. This application addresses the technical bottleneck in existing vehicle network diagnostic data sharing where raw data must be decrypted into plaintext during the computation stage, leading to privacy leaks. Through a collaborative design of secret sharing and secure multi-party computation, it achieves data usability without visibility, releasing the value of diagnostic data elements while protecting privacy. Specifically, the method includes the following steps S1-S5.

[0033] In step S1, the on-board terminal (e.g., a vehicle infotainment system, T-BOX, or smart cockpit domain controller with computing and communication capabilities) collects the vehicle's raw diagnostic data in real time. The raw diagnostic data includes: engine speed, vehicle speed, accelerator pedal opening, brake pressure, battery voltage, motor temperature, and fault codes (DTCs) from each electronic control unit (ECU) on the Controller Area Network (CAN) bus.

[0034] To facilitate subsequent processing, the vehicle-mounted terminal preprocesses the raw diagnostic data to obtain structured feature data. In one specific embodiment, this preprocessing process includes the following sub-steps:

[0035] S121, raw data stream is acquired through vehicle bus network. The raw data stream is a CAN message sequence, and each message contains an identifier (ID) and an 8-byte data field.

[0036] S122, the raw data stream is parsed and cleaned. Specifically, based on the pre-imported DBC file, the hexadecimal message data corresponding to each CAN ID is parsed into physical values ​​(e.g., 0x00-0xFF is mapped to vehicle speeds of 0-255 km / h). Simultaneously, obviously abnormal data points are removed, such as values ​​exceeding the sensor range or with a jump rate exceeding a preset threshold, thereby extracting time-series data from multiple preset signal channels (e.g., engine speed, vehicle speed, accelerator pedal opening, brake pressure, etc.).

[0037] S123, the above time series data is divided into fixed time windows and encoded into a fixed-dimensional feature matrix to obtain the structured feature data, wherein the time window length is set to 10 seconds and the sliding step is 5 seconds.

[0038] In one embodiment, the encoding method can be any of the following:

[0039] For each signal channel within each time window, calculate its maximum value, minimum value, mean, variance, kurtosis, skewness, and interquartile range. Concatenate the statistical characteristics of all channels into a one-dimensional vector as structured feature data.

[0040] The time-series data of multiple signal channels within the time window are normalized to the range of 0 to 255, and arranged into a two-dimensional grayscale matrix with the number of channels as rows and the time series points as columns, which is the structured feature data.

[0041] After preprocessing, the vehicle terminal splits the structured feature data into multiple first secret fragments based on a secret sharing algorithm. In a specific embodiment, the Shamir secret sharing scheme is adopted, which includes the following sub-steps:

[0042] S111, the vehicle terminal treats the structured feature data (e.g., a feature vector of length L, or a grayscale matrix of length H×W) as a whole as a large integer secret S. If the data volume is large, it can be converted into a byte stream and concatenated into an integer. Assuming the structured feature data is a 128-dimensional floating-point vector, each floating-point number is multiplied by 10^6 and rounded down, and then concatenated in order into a large integer S of 1024 bytes.

[0043] S112, the vehicle-mounted terminal constructs a random Polynomial of degree: Where t is the minimum number of fragments required to reconstruct the secret (e.g., t=3), and the coefficients a1, a2, …, a_{t-1} are randomly generated large integers (usually of the same order as S). All operations of the random polynomial are performed in a finite field GF(p) defined by a large prime number p (e.g., p > S and p > all coefficients).

[0044] S113, the vehicle-mounted terminal assigns a unique public identifier to each target edge computing node (e.g., roadside unit RSU, 5G base station edge cloud server, or regional aggregation node). (Values ​​can be 1, 2, 3, ..., not exceeding p-1), and the public identifier... Substitute the polynomial into the given polynomial and calculate the corresponding function value. . ( , The first secret fragment, which is sent to the i-th edge computing node, is of a size comparable to the original secret S, but a single fragment cannot recover any information about S.

[0045] According to the above technical solution, the original diagnostic data is split into multiple fragments through Shamir secret sharing. Each fragment does not leak the original data when it is transmitted or stored separately, so that the data remains encrypted after leaving the vehicle terminal, laying the foundation for subsequent secure multi-party computation.

[0046] Subsequently, the vehicle terminal sends each of the first secret fragments to at least two edge computing nodes via a V2X communication link (e.g., cellular vehicle-to-everything (C-V2X) or dedicated short-range communication (DSRC)). To ensure the feasibility of subsequent reconfiguration, the number of target edge computing nodes to be sent should not be less than a threshold t, preferably t+1 to 2t (e.g., when t=3, sending to 4 to 6 edge nodes).

[0047] In step S2, the central aggregation server (e.g., a data analytics platform deployed in the cloud or a regional center) issues a joint computing task based on each edge computing node that has received the first secret shard. The purpose of the joint computing task is to collaboratively complete a certain computing objective using secret shards distributed across multiple edge nodes without leaking the original data.

[0048] In one embodiment of this application, the joint computation task is a federated learning model training task, the goal of which is to train a global neural network model for vehicle fault diagnosis (e.g., a classification model for predicting engine or battery health status). The input of this model is the structured feature data generated in step S1, and the output is a fault type probability distribution, specifically including the following sub-steps:

[0049] S21, each edge computing node uses the first secret shard stored locally (i.e., the sharding of partial diagnostic data from different vehicle terminals) to collaboratively compute the model parameter update amount (i.e. gradient) of this round of federated learning in the form of secret shards based on a secure multi-party computation protocol, thereby obtaining the model parameter update amount shard.

[0050] In one embodiment, the secure multi-party computation protocol adopts an arithmetic circuit computation framework based on secret sharing. The loss function of the federated learning model is L(w), and the goal is to compute the gradient ∇L(w). Since the model parameters w and training data exist in the form of fragments on each node, it is necessary to securely implement basic operations such as addition and multiplication. The addition operation is directly performed by adding the fragments locally, while the multiplication operation is implemented through pre-distributed Beaver triples.

[0051] Specifically: During the offline phase, the system pre-distributes a set of Beaver triples ([a], [b], [c]) satisfying c = a * b through a triple generator (either a trusted third party or generated using homomorphic encryption). Each edge computing node obtains a slice of this triple. When it is necessary to calculate the product of two secret values ​​[x] and [y], each node calculates [d] = [x] - [a] and [e] = [y] - [b] locally, and broadcasts the slices of [d] and [e] to all participating nodes. After each node reconstructs the plaintext d and e, it calculates [z] = [c] + d·[b] + e·[a] + d·e locally. [z] is the correct slice of [x·y]. By combining addition and secure multiplication, the secure calculation of all gradient calculation formulas in linear regression, neural network forward propagation, and back propagation is completed, and each edge computing node obtains a gradient slice. .

[0052] In a preferred embodiment, to further enhance privacy protection, before calculating the gradient slice, each edge computing node adds random noise that satisfies a Laplace or Gaussian distribution to the gradient slice locally, so that the parameters of the finally reconstructed global model satisfy the differential privacy definition, thereby preventing the model from back-inferring individual vehicle data. For example, for the gradient slice [g], each node adds noise [η] locally, where η follows a Laplace distribution with a scale parameter λ=0.1, resulting in the noisy gradient slice [g'] = [g] + [η], and subsequent calculations are based on [g'].

[0053] In a preferred embodiment, the central aggregation server simultaneously publishes multiple joint computing tasks, such as simultaneously training a fault diagnosis model and querying driving behavior statistics. Each task shares the same set of secret shards but uses different secure computing logic. Each edge computing node executes multiple secure computing circuits in parallel to improve computing efficiency.

[0054] S22, each edge computing node will fragment the previously stored global model parameters. Pieces with the model parameter update amount (That is, gradient slices multiplied by the learning rate η, for example, η=0.01) are safely added together: This yields the updated global model parameter slices, where... That is, it serves as a slice of the intermediate calculation result.

[0055] According to the above technical solution, through a secure multi-party computation protocol, each edge computing node can collaboratively calculate the update amount of model parameters without obtaining the original fragment content of other nodes throughout the process, thus achieving the core requirement of "data available but not visible".

[0056] It should also be noted that those skilled in the art will understand that joint computation tasks are not limited to federated learning training, but can also be statistical queries (such as mean, variance, histogram), anomaly detection, or cluster analysis, as long as the computation process can be represented as a combination of addition and multiplication, it can be completed collaboratively in a fragmented form through the above-mentioned secure multi-party computation protocol.

[0057] In step S3, the central aggregation server collects intermediate computation result fragments from a preset number of edge computing nodes. Based on the Shamir secret sharing principle, the minimum number of fragments required to reconstruct the original secret is a threshold t. Therefore, the preset number is not less than the minimum number of fragments required to reconstruct the secret, threshold t (e.g., t=3). The central aggregation server collects at least 3 different ( , Yes, among them That is, the value calculated by the i-th edge computing node. The corresponding function value slices.

[0058] In a preferred embodiment, when an edge computing node goes offline or times out, the central aggregation server automatically excludes it from the current computing round and selects other nodes that have received shards to participate in the reconstruction. As long as the number of participating nodes is not less than the threshold t, the system can operate normally, thereby ensuring high availability. For example, if there are 5 edge nodes initially participating, and 1 node has a network outage, the central server can complete the reconstruction based on any t=3 of the remaining 4 nodes.

[0059] Subsequently, the central aggregation server recovers the complete intermediate calculation results based on the secret-sharing reconstruction algorithm. In one specific embodiment, Lagrange interpolation is used for reconstruction, given t distinct points. , The constant term S (i.e., the original secret) of the polynomial f(x), (x_t, y_t), is calculated by the following formula: i = 1 y_i - n_ i i j))] Here, all operations are performed within the finite field GF(p), where p is a large prime number greater than S and all coefficients. Through this calculation, the central aggregation server recovers the updated global model parameters in complete, plaintext form. .

[0060] According to the above technical solution, the central aggregation server only needs to collect no less than t shards to recover the intermediate calculation results, which not only ensures the feasibility of the calculation, but also avoids dependence on all shards and improves the robustness of the system.

[0061] In step S4, the central aggregation server bases its calculations on the complete intermediate results. Update the global diagnostic model, that is, update the parameters of the old model. Replace with This yields the updated global diagnostic model parameters.

[0062] In one embodiment, a dynamic iterative update step is also included: S41, the central aggregation server determines whether the updated global diagnostic model parameters meet the model convergence conditions. The convergence conditions can be any one or more of the following combinations: the loss function value is less than a preset threshold (e.g., 0.01), the L2 norm of the model parameter update is less than a preset threshold (e.g., 1e-4), or the preset maximum number of training rounds is reached (e.g., 100 rounds).

[0063] S42, if the convergence condition is met, then... This will serve as the final global diagnostic model parameter, ready for distribution.

[0064] S43, if the convergence condition is not met, the central aggregation server will... The new secret S' is considered as a new secret, and it is re-split into multiple second secret fragments in the same way as steps S112-S113, and distributed to each edge computing node. Each edge computing node uses the second secret fragment to replace the previously stored global model parameter fragments and starts the next round of joint computing task, that is, repeating steps S21, S22, S3 and S4 until the model converges.

[0065] In a preferred embodiment, when distributing the final global model parameters, the central aggregation server prunes and quantizes the model weights. For example, it quantizes the 32-bit floating-point numbers into 8-bit integers and removes weights with absolute values ​​less than 0.01 to reduce communication bandwidth usage and adapt to the unstable environment of the vehicle network channel. After receiving the parameters, the vehicle terminals perform dequantization to recover the model according to the same quantization parameters. When the model converges, the central aggregation server distributes the final global diagnostic model parameters to each vehicle terminal participating in the training through a secure communication channel (e.g., a TLS-based encrypted link).

[0066] According to the above technical solution, the global model is continuously optimized through an iterative update mechanism. In each iteration, the model parameters are always transferred between edge nodes in the form of shards. The central server only obtains plaintext during reconstruction, but what is reconstructed is the aggregated model parameters rather than the original diagnostic data, thereby further reducing the risk of privacy leakage.

[0067] In step S5, the vehicle terminal uses the received final global diagnostic model parameters to configure the local diagnostic model. The global diagnostic model parameters are lightweight neural networks (e.g., a multilayer perceptron with 2-3 hidden layers or a one-dimensional convolutional neural network), which can be directly deployed on the embedded chip of the vehicle's infotainment system to meet real-time inference requirements.

[0068] When the vehicle is actually running, the onboard terminal collects new local data in real time (e.g., time-series data such as engine speed, vehicle speed, accelerator pedal opening, and coolant temperature over the past 30 seconds), and obtains structured feature data according to the same preprocessing procedure as in step S1 (time window division, feature encoding). This feature data is input into the configured local diagnostic model, and a forward propagation calculation is performed. The output layer of the model is a softmax layer, which outputs the probability distribution of different fault categories. The onboard terminal determines whether a fault exists and its type based on a preset probability threshold (e.g., 0.7), and outputs the diagnostic analysis results to the driver through the onboard display, voice prompts, or dashboard warning lights.

[0069] Furthermore, the diagnostic results may be either "There is a potential fault in the engine combustion system, and it is recommended to check the spark plugs soon" or "The efficiency of the brake energy recovery system is below the threshold, please check the brake pads".

[0070] According to the above technical solution, the vehicle terminal uses a global model for local inference, eliminating the need to upload any data to the cloud or edge, thus protecting the privacy of real-time data and achieving low-latency real-time diagnosis.

[0071] All parts not covered in this application are the same as or can be implemented using existing technology. Although embodiments of this application have been shown and described, it will be understood by those skilled in the art that various changes, modifications, substitutions and variations can be made to these embodiments without departing from the principles and spirit of this application, the scope of which is defined by the appended claims and their equivalents.

Claims

1. A method for sharing vehicle network diagnostic data using privacy computing, characterized in that, Includes the following steps: S1. The vehicle terminal collects the original diagnostic data of the vehicle, preprocesses the original diagnostic data to obtain structured feature data, and splits the structured feature data into multiple first secret fragments based on the secret sharing algorithm, and sends each first secret fragment to at least two edge computing nodes respectively. S2. The central aggregation server publishes joint computing tasks based on the edge computing nodes that have received the first secret fragment. The edge computing nodes execute a secure multi-party computation protocol based on the first secret fragments received from different vehicle terminals to obtain intermediate computing result fragments corresponding to the joint computing tasks. S3. The central aggregation server collects intermediate computing result fragments from a preset number of edge computing nodes and recovers the complete intermediate computing results based on a secret-sharing reconstruction algorithm. S4. The central aggregation server updates the global diagnostic model based on the complete intermediate calculation results, obtains the updated global diagnostic model parameters, and sends the updated global diagnostic model parameters to the vehicle terminal. S5. The vehicle terminal uses the received global diagnostic model parameters to configure the local diagnostic model and performs diagnostic analysis on the local data.

2. The method according to claim 1, characterized in that, The structured feature data is split into multiple first secret fragments based on the secret sharing algorithm, including the following steps: S111, the vehicle terminal identifies the structured feature data as the secret S to be shared; S112, The vehicle terminal constructs a random polynomial, where the constant term is a secret S; S113, the vehicle terminal assigns a unique public identifier x_i to each target edge computing node, and substitutes the public identifier x_i into a polynomial to determine the corresponding function value y_i, where the (x_i, y_i) pair constitutes the first secret fragment sent to the i-th edge computing node.

3. The method according to claim 2, characterized in that, The random polynomial is a polynomial of order t-1, where t is the minimum number of shards required to reconstruct the secret, and t is not greater than the total number of edge computing nodes.

4. The method according to claim 3, characterized in that, In step S3, the preset number is not less than the minimum number of fragments threshold t required to reconstruct the secret.

5. The method according to claim 1, characterized in that, In step S2, the joint computation task is the federated learning model training task, which includes the following steps: S21. Each edge computing node uses the first secret shard stored locally to collaboratively compute the model parameter update amount of this round of federated learning in the form of secret shards based on the secure multi-party computation protocol, and obtains the model parameter update amount shard. S22. Each edge computing node safely adds the previously stored global model parameter fragments and model parameter update fragments to obtain the updated global model parameter fragments. The updated global model parameter fragments form the intermediate computing result fragments.

6. The method according to claim 5, characterized in that, In step S21, based on the secure multi-party computation protocol, the gradient of the loss function of the federated learning model with respect to the model parameters is calculated, and gradient slices are obtained.

7. The method according to claim 6, characterized in that, Based on a secure multiplication protocol using secret sharing, triples are pre-distributed to each edge computing node. The edge computing nodes use the pre-distributed triples to shard locally, exchange the masked shard information, and collaboratively calculate the result shard corresponding to the product of the two secret shards.

8. The method according to claim 1, characterized in that, In step S1, the raw diagnostic data is preprocessed to obtain structured feature data, including the following steps: S121, raw data stream is collected from the vehicle bus network, the raw data stream includes the controller area network message sequence; S122, parse and clean the raw data stream, and extract the timing data of multiple preset signal channels; S123 divides the time series data into fixed time windows and encodes them into a fixed-dimensional feature matrix to obtain structured feature data.

9. The method according to claim 8, characterized in that, In step S123, the feature matrix is ​​encoded into a fixed dimension, including any of the following: Statistical feature extraction of signal values ​​within the time window; Convert time-series data into a grayscale matrix.

10. The method according to claim 1, characterized in that, It also includes the following steps: S41, The central aggregation server determines whether the updated global diagnostic model parameters meet the model convergence conditions; S42, if satisfied, then the updated global diagnostic model parameters will be used as the final global diagnostic model parameters; S43. If not satisfied, the central aggregation server will re-split the updated global diagnostic model parameters into multiple second secret fragments and distribute them to each edge computing node. Each edge computing node will use the second secret fragments to replace the previously stored global model parameter fragments and start the next round of joint computing tasks.

Images