Health data processing method and system based on distributed account book library

Abstract

The invention relates to the technical field of medical information processing, in particular to a health data processing method and system based on a distributed ledger library, and the method comprises the steps: a node firstly links a health data abstract to obtain a differential privacy budget token and a reversible tensor hash key; then, carrying out encryption training on local model parameters by using the key, injecting Gaussian noise according to budget to generate a differential protection gradient, and carrying out uplink together with zero-knowledge proof; the account book end decrypts the threshold value, uses a structural equation model to deduce a causal correction matrix according to the reputation weight aggregation gradient, and automatically adds a budget and turns the key when the concept drifts and the budget is insufficient; the operation mechanism splices the aggregation parameters and local parameters, generates a gating vector in combination with a causal correction matrix and a reputation weight, outputs disease risk prediction, and only uploads prediction hash and error information; chain-level audible privacy protection, dynamic budget management and hybrid deviation suppression are realized, and the safety and accuracy of a cross-institution medical model are improved.

Description

Technical Field

[0001] The present invention relates to the technical field of medical information processing, and particularly to a health data processing method and system based on a distributed ledger library. Background Art

[0002] Health data integrates multi-modal information such as electronic medical records, physiological monitoring, imaging, and gene sequencing. It is not only the key fuel for precision medicine but also subject to strict legal constraints on privacy and data sovereignty. To collaboratively train high-value models in a cross-institutional scenario, the system must simultaneously meet three requirements: First, the whole process is traceable, capable of external auditing of each data call and privacy budget consumption; second, it is decentralized to avoid single-point failures and trust monopolies; third, it has the ability to adapt to non-static factors such as population structure and label drift.

[0003] The existing technology mainly adopts the combination of "centralized parameter server + traditional federated learning + fixed differential privacy budget" (existing literature, publication number: CN119494118A). After the gradient is uploaded with noise, it depends on the central node to converge and update. Although it reduces the plaintext risk to a certain extent, it still has the following defects: 1. Off-chain closed aggregation lacks third-party verifiability, making it difficult to prove that the noise intensity, budget deduction, and model update are all executed as agreed; 2. The privacy budget and key are statically configured. Once the data distribution undergoes concept drift, the model performance deteriorates and the budget cannot be automatically supplemented or the key cannot be replaced, resulting in training interruption or privacy level imbalance; 3. Causal identification of confounding variables is not done, and only statistical averaging is used to merge gradients, which is prone to cumulative bias under different institutional population differences. Summary of the Invention

[0004] In view of the many problems existing in the above-mentioned prior art, the present invention provides a health data processing method and system based on a distributed ledger library. The present invention writes the health data digest, privacy budget, and quantum hash key into the distributed ledger; nodes encrypt and train the model parameters according to the key, and upload the gradient commitment protected by Gaussian noise and zero-knowledge proof; the ledger decrypts at the threshold and aggregates to generate a global model according to reputation and causal correction, and at the same time automatically supplements the budget and updates the key according to concept drift. This closed-loop realizes verifiable privacy, dynamic compliance, and confounding suppression.

[0005] A health data processing method based on a distributed ledger library includes: Serializing first health data and calculating digest data, and submitting it to the distributed ledger library to obtain privacy budget token data and reversible tensor hash key data; Perform reversible tensor hashing encoding on the first model fragment parameter data using the said key, train differential gradient data based on the first health data, inject noise into the differential gradient data according to the privacy budget to form differentially protected gradient data, generate an encrypted commitment and zero-knowledge proof data and write them into the distributed ledger library, and at the same time deduct the privacy budget token data; After the distributed ledger library verifies the zero-knowledge proof data, decrypt the encrypted commitment to obtain the decrypted gradient data, generate the second model fragment parameter data based on the reputation weight, infer the causal correction matrix data, and update the balance of the privacy budget token data and the reversible tensor hashing key data according to the concept drift index; At the operator side, combine the second model fragment parameter data with the first model fragment parameter data to form complete model data, generate a gating vector based on the causal correction matrix data and the reputation weight data to obtain disease risk prediction data, write the hash value of the prediction data into the distributed ledger library, and upload the model error information for the next round of training after obtaining the true label.

[0006] Preferably, the summary data is calculated through a one-way secure hashing algorithm, and the output length of the one-way secure hashing algorithm is fixed and can uniquely identify the first health data.

[0007] Preferably, the noise is Gaussian noise with a mean of zero, and the noise variance is calculated and determined according to the two-norm of the differential gradient data and the single-step privacy budget value in combination with the differential privacy algorithm.

[0008] Preferably, the zero-knowledge proof data is generated through a polynomial commitment type zero-knowledge proof protocol, and the verification process of the polynomial commitment type zero-knowledge proof protocol is executed on the consensus nodes of the distributed ledger library.

[0009] Preferably, the encrypted commitment is generated through the elliptic curve Pedersen commitment algorithm, the Pedersen commitment algorithm uses a random factor output by a hardware random number generator, and the encrypted commitment value remains tamper-proof after being written into the distributed ledger library.

[0010] Preferably, the reputation weight data is recursively updated by the extended Kalman filter according to the state vector data and the previous round of reputation weight data, and is normalized after the update for weighting the decrypted gradient data.

[0011] Preferably, the causal correction matrix data is obtained by performing causal inference on the decrypted gradient data and the label statistical information through a structural equation model, and the causal correction matrix data is stored in the side chain after being symmetrically encrypted.

[0012] Preferably, when the concept drift index data exceeds the preset threshold and the balance of the privacy budget token data is lower than the preset ratio, the distributed ledger library adds privacy budget token data and synchronously rotates the reversible tensor hashing key data.

[0013] Preferably, the gating vector is obtained by element-wise multiplication of the diagonal elements of the causal correction matrix data and the reputation weight data followed by conversion through a smoothing activation function, and the gating vector is used to modulate the output of the complete model data.

[0014] A health data processing system based on a distributed ledger library for implementing the health data processing method based on a distributed ledger library, the system comprising: A summary registration module for serializing first health data and calculating summary data, and submitting the summary data to the distributed ledger library to obtain privacy budget token data and reversible tensor hash key data; An encoding training module for loading reversible tensor hash key data, performing reversible tensor hash encoding on first model fragment parameter data, completing local training based on the first health data to generate differential gradient data, injecting noise into the differential gradient data according to the privacy budget token data to obtain differentially protected gradient data, and generating encrypted commitments and zero-knowledge proof data and writing them into the distributed ledger library, while deducting the privacy budget token data; An aggregation update module for decrypting the encrypted commitment to obtain decrypted gradient data after the distributed ledger library verifies the zero-knowledge proof data, generating second model fragment parameter data based on the reputation weight, inferring causal correction matrix data, and updating the balance of the privacy budget token data and rotating the reversible tensor hash key data according to the concept drift index; An inference feedback module for combining the second model fragment parameter data and the first model fragment parameter data at the operation institution end to form complete model data, calculating a gating vector based on the causal correction matrix data and the reputation weight data to obtain disease risk prediction data, writing the hash value of the disease risk prediction data into the distributed ledger library, and uploading model error information for use in the next round of training after obtaining the true label.

[0015] Compared with the prior art, the advantages and beneficial effects of the present invention are as follows: The present invention realizes a privacy protection effect with measurable node budget consumption and auditable on-chain through technical means of a distributed ledger library + semi-homogeneous privacy budget tokens.

[0016] The present invention realizes the verifiability of the correctness of decentralized aggregation through technical means of threshold decryption + zero-knowledge proof, completely eliminating the single-point trust gap.

[0017] The present invention realizes real-time compensation for confounding factors through technical means of a causal correction matrix + gating vector modulation, significantly improving the model generalization ability.

[0018] The present invention realizes adaptive privacy compliance of the model in scenarios of label distribution change through technical means of concept drift detection-driven budget replenishment and key rotation. Description of the Drawings

[0019] Figure 1 is a schematic flowchart of the method of the present invention; Figure 2 is a schematic diagram of budget and key adaptation in the present invention; Figure 3 is a schematic diagram of gated vector generation in the present invention; Figure 4 is a block diagram of the structure of the system of the present invention. Detailed implementation manners

[0020] Hereinafter, embodiments of the present disclosure will be described with reference to the accompanying drawings. However, it should be understood that these descriptions are merely exemplary and are not intended to limit the scope of the present disclosure. In the following detailed description, for the sake of explanation, many specific details are set forth in order to provide a comprehensive understanding of the embodiments of the present disclosure. However, obviously, one or more embodiments can also be implemented without these specific details. In addition, in the following description, descriptions of well-known structures and technologies are omitted to avoid unnecessarily confusing the concepts of the present disclosure.

[0021] The terms used herein are merely for describing specific embodiments and are not intended to limit the present disclosure. The terms "including", "comprising", etc. used herein indicate the presence of the described features, steps, operations, and / or components, but do not exclude the presence or addition of one or more other features, steps, operations, or components.

[0022] All terms used herein (including technical and scientific terms) have the meanings commonly understood by those skilled in the art, unless otherwise defined. It should be noted that the terms used herein should be interpreted as having a meaning consistent with the context of this specification and should not be interpreted in an idealized or overly rigid manner.

[0023] As Figure 1 shown, a health data processing method based on a distributed ledger library includes: Serializing the first health data and calculating summary data, and submitting the summary data to the distributed ledger library to obtain privacy budget token data and reversible tensor hash key data; The first health data includes demographic information, vital signs, laboratory test indicators, medical imaging paths, and gene sequencing paths. Directly storing on the chain will cause privacy leakage, so a secure hash function is used to generate a fixed-length summary. The hash function satisfies unidirectionality and collision resistance, and can ensure that different inputs get different outputs and the input cannot be deduced from the output. The distributed ledger library mints privacy budget tokens using this summary as an index, and derives a quantum phase angle vector using a pseudorandom function, and then realizes decentralized management through key sharding, so as to satisfy both traceability and privacy security.

[0024] UTF-8 encoding is performed on the first health data to obtain a byte sequence . Using a secure hash function to calculate the digest:

[0025] where represents the digest data, with a fixed length of 32 bytes; represents the one-way hash function SHA-256. The digest data and the differential privacy total budget are submitted as parameters to the smart contract RegisterData. After the contract state is written to the corresponding block, two operations are immediately performed: Privacy budget token minting. The ledger library creates a balance for the indexed tokenId in the semi-fungible token contract:

[0026] where represents the initial balance of the privacy budget token data, represents the differential privacy total budget.

[0027] Quantum key generation and sharding. The consensus node uses a pseudo-random function to calculate the quantum phase angle vector

[0028] The vector consists of elements 0 or and is used as the key for reversible tensor hash encoding. Subsequently, the Shamir key sharding method is used to split into five pieces, each piece is stored in a different node, and only any three pieces are required to reconstruct the key.

[0029] Through the present invention, the digest data serves as an immutable index to avoid duplicate registration and support subsequent audits. The privacy budget token data is deducted at the minimum budget granularity to provide an accurate consumption record for the differential privacy algorithm. The quantum key sharding storage reduces the risk of single-point leakage and enables the key recovery to be unaffected by any node downtime. The ledger only stores the digest and tokens, without the reversible original information, meeting the requirements of privacy regulations.

[0030] In one embodiment, taking a single piece of health data as an example, the length of the byte stream obtained after field serialization is . Performing SHA-256 calculation to obtain a hexadecimal string:

[0031] Submitting the parameter and the budget To the chain. The contract generates a tokenId value:

[0032] And write it into the event LogRegister. The balance of the budget token Is recorded in the account. The consensus node calls a pseudo-random function on the tokenId to output a length Of the vector , and then splits and distributes the key slices. After receiving three slices through the private message channel, the parties recombine In the trusted execution environment, thus completing the registration process. Actual tests show that the summary calculation takes 0.5ms, and the average on-chain confirmation takes 3s, meeting the real-time requirements of medical data.

[0033] Preferably, the summary data is obtained by calculating through a one-way secure hash algorithm. The output length of the one-way secure hash algorithm is fixed and can uniquely identify the first health data.

[0034] When processing the first health data in the distributed ledger library environment, the present invention first generates summary data by using a one-way secure hash algorithm. This operation not only establishes a unique index for subsequent budget and key distribution, but also avoids uploading the original health data to the chain, thus meeting the privacy isolation requirements.

[0035] One-way secure hash algorithm Has two cryptographic properties: fixed-length output and collision resistance: The fixed-length output ensures that input data of any length is mapped to a hash value with a constant length, facilitating ledger storage and comparison; the collision resistance ensures that within the feasible computational complexity, it is impossible to find two different inputs that generate the same hash value, thereby ensuring the uniqueness of the index.

[0036] In the present invention, the first health data forms a byte sequence After field sorting and UTF-8 encoding. Applying a hash function to Gets:

[0037] Where: Represents the summary data; Represents the one-way secure hash algorithm; Represents the byte sequence of the first health data after encoding.

[0038] The hash output length is denoted as: , Is a fixed constant and does not change with the size of .

[0039] In practical applications, byte serialization reads fields in a fixed order of demographic information, vital signs, laboratory tests, medical imaging paths, and gene sequencing paths, uniformly encodes text and numerical values into a UTF-8 byte stream, and obtains .

[0040] Hash calculation, calls the SHA-256 implementation that complies with the FIPS180-4 standard to Execute a complete compression round to obtain a 32-byte digest .

[0041] The unique index registration writes as a parameter into the smart contract RegisterData; the smart contract event is permanently recorded in the block , forming an immutable index.

[0042] Through the present invention, from the collision resistance, it can be known that if there is then there is . Therefore, each first health data corresponds to a unique digest on the chain, without duplicate records. The one-way property ensures that it is impossible to reverse deduce from , and the ledger nodes have no right to access sensitive plaintext. The fixed-length attribute makes the storage space on the chain constant, independent of the size of the original data, and reduces the block load.

[0043] In one embodiment, a hospital generates a data record containing five fields. After serialization, the byte length is approximately . Executing SHA-256 gives a digest in hexadecimal form:

[0044] Length bytes, meeting the fixed-length characteristic. This digest is written into the block at height 7,259 along with the transaction. Subsequently, the ledger library mints privacy budget tokens with as the index and derives a reversible tensor hash key to prepare the budget and key for the subsequent training process of the hospital. Querying the same height on the chain browser can verify the existence and immutability of the digest, but it is impossible to restore the original medical record information.

[0045] This embodiment shows that the one-way secure hash algorithm effectively achieves the triple goals of data uniqueness, privacy security, and block lightweighting in the present invention, laying a trustworthy foundation for all subsequent links of distributed privacy protection learning.

[0046] Perform reversible tensor hashing encoding on the first model fragment parameter data using the said key, train differential gradient data based on the first health data, inject noise into the differential gradient data according to the privacy budget to form differentially private gradient data, generate encrypted commitments and zero-knowledge proof data and write them into the distributed ledger library, and at the same time deduct the privacy budget token data; This embodiment describes how to perform an encryption transformation on the first model fragment parameter data using a reversible tensor hashing key in a distributed ledger library environment, and then complete differential privacy training, confidential commitment generation, and ledger entry into the chain. This link undertakes two core functions in the entire health data processing process: on the one hand, it protects the local model parameters from being snooped during training; on the other hand, it provides a verifiable and measurable record of differential privacy consumption to the chain.

[0047] Reversible tensor hashing encoding is essentially a controlled phase mapping that can rotate the parameter space into a quantum-friendly coordinate system while keeping the gradient direction unchanged. The participating party uses the phase angle vector issued on the chain as the private key and can perform forward and inverse transformations only by holding it locally. This mechanism ensures that subsequent gradients and noise always remain in the encoded domain, and the chain nodes only see the encrypted commitments and cannot reverse-engineer the plaintext gradients.

[0048] Noise injection follows the differential privacy theory: for a single training round, zero-mean Gaussian noise is superimposed at the gradient level, and its variance is jointly determined by the gradient sensitivity and the budget limit. The encrypted commitment is constructed using the elliptic curve Pedersen algorithm. The encrypted commitment and the zero-knowledge proof jointly ensure the correctness and integrity of the verification on the chain. At the same time, the privacy budget token data is deducted synchronously at the contract level to form a traceable ledger record.

[0049] In practical applications, after loading the phase angle vector , perform reversible tensor hashing encoding on the first model fragment parameter data :

[0050] where represents the encoded domain parameter tensor; represents the discrete quantum Fourier mapping controlled by the phase angle vector . Perform a forward-backward propagation on the encoded once with a batch size of sixty-four to obtain the differential gradient in the plaintext domain:

[0051] Then map it to the encoded domain:

[0052] To meet the single-step differential privacy constraint, calculate the variance of the noise that needs to be added:

[0053] wherein represents the gradient sensitivity, defined as the maximum possible value; represents the single-step differential privacy budget; represents the differential privacy failure rate.

[0054] Adding noise to the gradient in the coding domain:

[0055] Remapping it back to the plaintext domain to obtain the differentially protected gradient:

[0056] For Generate an elliptic curve Pedersen commitment:

[0057] wherein and are the public primitives of the BN254 curve; represents a random factor generated by a hardware random number generator.

[0058] To prove that the commitment value is indeed generated by legitimate training and differential privacy noise, a proof is constructed using a polynomial commitment type zero-knowledge protocol . The transaction CommitUpdate uploads along with the local model mean squared error to the chain. After confirmation, the smart contract performs two operations: Through the solution of the present invention, all intermediate gradients are represented as commitment values on the chain. Even consensus nodes cannot reverse-engineer the original gradients, improving the privacy strength of training. Each successful CommitUpdate triggers budget deduction, and the ledger automatically forms an auditable consumption curve. The zero-knowledge proof allows chain nodes to verify the noise amplitude and training legality without exposing the gradient details, ensuring the credibility of differential privacy implementation.

[0059] In one embodiment, let the sensitivity upper bound be the single-step budget be the failure rate be . Substituting into the equation gives:

[0060] The element variance of the random noise vector is . It takes 16 ms to perform one forward-backward propagation on the RTXA2000 graphics card, 5 ms for noise addition and commitment generation, and 120 ms for zero-knowledge proof generation. After on-chain confirmation, the budget balance is deducted from 5.0 to 4.8, and the transaction hash is included at height 7.265. This example verifies that this link completes differential privacy training and on-chain commitment writing within an acceptable latency, while achieving fine-grained budget deduction and confidential gradient protection.

[0061] Preferably, the noise is Gaussian noise with a mean of zero, and the noise variance is calculated and determined according to the combination of the two-norm of the differential gradient data and the single-step privacy budget value using the differential privacy algorithm.

[0062] Under the distributed ledger library framework of the present invention, random noise needs to be added to the differential gradient data in each training round to meet the single-step differential privacy constraint. A Gaussian distribution with a mean of zero is selected as the noise model because the Gaussian distribution has analytical composability, is easy to verify on-chain, and can be directly associated with the privacy budget through a closed-form formula.

[0063] The differential privacy definition requires that the output distributions of any two datasets that differ by one record be approximately the same. For a single gradient update, only the sensitivity of the gradient tensor needs to be controlled. Let:

[0064] where represents the two-norm of the differential gradient data, represents the plaintext differential gradient tensor. If independent Gaussian noise with a mean of zero and a variance of is added to the gradient, then under the differential privacy framework, it is required to satisfy:

[0065] where represents the Gaussian noise variance; represents the single-step privacy budget value; represents the differential privacy relaxation probability. This formula is the generally recognized minimum variance closed-form solution in the literature, does not depend on a specific data distribution, and can be directly calculated off-chain and written into the transaction field for auditing by consensus nodes.

[0066] In practical applications, after completing one forward-backward propagation locally, calculate , and the software framework automatically truncates the gradient to ensure that the two-norm does not exceed the preset upper bound. According to the above formula, with fixed and calculate .

[0067] Call the hardware random number instruction to generate an independent and identically distributed Gaussian vector , and add it element by element to Obtain the differential protection gradient tensor .

[0068] Use to continue generating encrypted commitments and zero-knowledge proofs, and write them into the transaction field dpCost. After successful verification, the smart contract deducts the same value from the privacy budget token data balance.

[0069] Through the solution of the present invention, the noise variance is uniquely determined by the formula. The on-chain nodes can determine that the noise intensity complies with the regulations through recalculation ; differential privacy guarantee is completely independent of the model structure and data distribution, and only depends on the second norm sensitivity and budget, which is convenient for unified auditing; budget deduction and noise injection occur synchronously, and the ledger database automatically records the privacy loss of each round without additional logs.

[0070] In one embodiment, let the single-step budget , the failure rate , and the value measured in one training round is .

[0071] Substitute into the formula to obtain the noise variance:[[]]

[0072] The experimental platform generates a Gaussian vector with a matching variance through the Intel AES-NI random instruction and completes noise superposition. The generated encrypted commitments and zero-knowledge proofs are uploaded to the chain with the transaction. After the block is confirmed, the privacy budget balance is automatically reduced by 0.3. Subsequently, the consensus nodes on the chain use the recorded on the chain and recalculate with the formula . If the result is consistent with the transaction field, it is determined that this round of training meets the differential privacy requirements.

[0073] Preferably, the zero-knowledge proof data is generated through the polynomial commitment type zero-knowledge proof protocol, and the verification process of the polynomial commitment type zero-knowledge proof protocol is executed on the consensus nodes of the distributed ledger database.

[0074] The present invention requires that the on-chain nodes can determine two things: the differential protection gradient tensor is indeed composed of the legal gradient tensor and the Gaussian noise with a mean of zero and a variance superimposed; the noise variance meets the single-step differential privacy budget .

[0075] To avoid leakage And its noise vector, the polynomial commitment-based zero-knowledge proof protocol (hereinafter referred to as the PLONK protocol) is used in the present invention. The PLONK protocol has the advantages of one-time proof, multiple verifications, and a constant-level proof length, and on-site verification only requires bilinear pairing operations, which is easy to be transplanted into the consensus node environment of the distributed ledger library.

[0076] Model the computing logic (gradient generation and noise injection) as an arithmetic circuit, and then transform it into an equivalent polynomial equation. The prover submits polynomial commitments and evaluation points, and the verifier only needs to verify whether the values of the polynomial at random points satisfy the equation to determine that the entire computation is correct.

[0077] Let: be the complete witness, and the components of are arranged in the circuit. The circuit constraints are divided into two categories: Gradient noise constraint:

[0078] Variance consistency constraint:

[0079] where represents the number of elements of the gradient tensor. The circuit is compiled into a constraint system over the field and then converted into a single polynomial identity:

[0080] where, represents the circuit selection polynomial; represents the observation polynomial, which is determined by the witness ; represents the annihilation polynomial, ensuring that the identity holds only under legal constraints. To hide , the prover uses the KZG commitment scheme to commit to :

[0081] where is the public generator; is the ceremony random number, which only exists in the public parameters; is the commitment value, with a fixed size.

[0082] Subsequently, generate a proof such that for randomly selected points it satisfies:

[0083] and the verifier can complete the verification at one time through bilinear pairing without knowing .

[0084] The generation process includes: 1. Circuit mapping, which writes and into the received execution environment, constructs a circuit after verifying against the variance formula; 2. Polynomial expansion, which generates using the Lagrange basis; 3. KZG commitment, which calculates and outputs it; 4. Evaluation point challenge, which derives a random point through the Fiat-Shamir transformation; 5. Proof generation, which calculates the evaluation value and packages it into . The size of the entire proof is fixed and does not grow with the gradient dimension.

[0085] On-chain verification: The consensus node has a built-in pairing pre-compiled contract Pair. The steps of the verification algorithm are as follows: 1. Parse and in the transaction fields; 2. Call Pair to complete a pairing operation and judge:

[0086] 3. If the equation holds, the transaction is valid, and is deducted from the privacy budget token data balance.

[0087] In the BN254 curve environment, the cost of a single pairing is about 5 ms, which meets the block time requirement.

[0088] Through the solution of the present invention, the consensus node can verify the legality without accessing the plaintext of the gradient; regardless of how the gradient dimension expands, the proof length is constant, and the on-chain storage and network load are predictable; the number of pairings is at a constant level, which is suitable for high-concurrency on-chain scenarios.

[0089] In one embodiment, under the gradient dimension condition of , the circuit depth is 18 kgates. The prover generates a commitment and a proof with a total of 832 bytes, and the generation time is 140 ms. The consensus node takes 4.7 ms to complete the verification by calling the pre-compilation. After the transaction is written to block height 7,312, the and byte streams can be retrieved by the on-chain browser, but the plaintext cannot be decoded, demonstrating both privacy and verifiability.

[0090] Preferably, the encrypted commitment is generated through the elliptic curve Pedersen commitment algorithm. The Pedersen commitment algorithm uses a random factor output by a hardware random number generator, and the encrypted commitment value remains tamper-proof after being written into the distributed ledger library.

[0091] After each round of training is completed, the present invention needs to write the existence of the differential protection gradient tensor and the legality of the differential privacy noise into the distributed ledger library, and prevent any node from obtaining the tensor content without decryption. For this purpose, the elliptic curve Pedersen commitment algorithm is used to implement an immutable encryption commitment.

[0092] The elliptic curve Pedersen commitment algorithm is based on the discrete logarithm problem. Given the curve generator and the independent basis , the commitment to the message scalar and the random factor is calculated as follows:

[0093] where represents the encrypted commitment value; represents the message to be hidden; represents the one-time random number; , is a subgroup of order prime number on the BN254 elliptic curve.

[0094] Since the discrete logarithm is insoluble in , any observer who only knows cannot simultaneously find and . At the same time, assuming that the random factor obeys the uniform distribution, the commitment satisfies computational hiding and binding: Computational hiding ensures that the commitment distributions corresponding to different messages overlap, blocking plaintext inference; Binding ensures that once is uploaded to the chain, the submitter can no longer find another set of for the same . The generation process includes: First, perform flattening and in-block normalization on the differential protection gradient tensor to obtain a scalar representation:

[0095] where maps the tensor to the interval. The random factor is output by the hardware random number generator and satisfies the uniform distribution. Subsequently, the commitment is calculated:

[0096] The commitment and the random factor are cached in the local security area, and the commitment value is written into the transaction , the same transaction also includes zero - knowledge proof data and budget deduction fields.

[0097] On - chain verification and solidification, after receiving the transaction, the consensus nodes perform two steps: call the zero - knowledge verification algorithm to confirm that it is indeed generated from legal gradients and noise; write it into the block along with the transaction hash. Since the block hash participates in subsequent blockchain consensus, any attempt to modify will damage the on - chain hash structure, equivalently achieving physical immutability.

[0098] Through the solution of the present invention, the content is not disclosed in the commitment, guaranteeing the privacy of the participating party models; the one - time randomness hardware random number generator avoids predictable random factors, further improving the computational concealment; after the commitment is uploaded to the chain, it is bound to the block hash, and any later modification will be rejected by the consensus rules; the commitment value is fixed in the form of compressed two - point coordinates, with a constant byte length and does not expand with the model scale.

[0099] In one embodiment, take and as independent bases generated for the trust ceremony. After flattening the tensors in one training round, we get: The output of the hardware random number generator is . Substitute and into the formula to calculate the commitment . Completing this operation within the Intel SGX environment takes 2.4 ms. The transaction is included in block height 7,345, and the browser can retrieve the hexadecimal commitment value but cannot deduce the original gradient, indicating that the solution successfully achieves the two goals of commitment concealment and persistent solidification.

[0100] As Figure 2 shown, after the distributed ledger library verifies the zero - knowledge proof data, it decrypts the encrypted commitment to obtain decrypted gradient data, generates the second model fragment parameter data based on the reputation weights, infers the causal correction matrix data, and updates the balance of the privacy budget token data and the reversible tensor hash key data according to the concept drift index; After the training node submits the encrypted commitment and zero - knowledge proof data to the chain, the distributed ledger library sequentially completes proof verification, gradient decryption, reputation - weighted aggregation, causal correction inference, and budget - key dynamic update.

[0101] The zero - knowledge proof data ensures that the commitment value indeed corresponds to legal gradients and differential privacy noise; threshold decryption uses the private key shards distributed among the consensus nodes to restore the gradient plaintext; the reputation weight mechanism dynamically adjusts the contributions of each node through historical errors; the causal correction matrix data structurally compensates for label confounding; the concept drift index data monitors the changes in label distribution and drives the rotation of privacy budgets and keys, forming a closed - loop self - adaptation.

[0102] After the zero - knowledge proof verification is completed, the consensus node calls the threshold decryption protocol Open the commitment:

[0103] where represents the decryption gradient data of the th participant. The reputation weight is obtained by normalizing the trust value output by the joint Kalman filter :

[0104] The global model increment is aggregated in a linearly weighted form:

[0105] where represents the model fragment parameter data. The causal correction matrix data is executed off - chain on the side chain through a structural equation model: The NOTEARS method is used to learn the adjacency matrix; the intervention effect is evaluated for each directed edge; the diagonal of the intervention matrix is extracted as the compensation weight, serialized and symmetrically encrypted for storage. The concept drift index data is measured by the KL divergence between the label distribution in the past thirty days

[0106] and the label distribution in the past ninety days : :

[0107] If is higher than the threshold and the balance of the privacy budget tokens is lower than the budget lower limit , the contract automatically adds a budget:

[0108] and calls the pseudo - random function:

[0109] Generate new reversible tensor hash key data, and then redistribute it using the Shamir secret sharing method.

[0110] Through the solution of the present invention, gradient encryption, zero - knowledge proof and threshold decryption jointly ensure that on - chain nodes can only see the verified plaintext gradients, resisting malicious uploads. The reputation weight Adjust in real time according to the model error to reduce the impact of noisy nodes on the global model. The causal correction matrix data explicitly eliminates potential confounding and improves the generalization ability of the joint model. The concept drift index data triggers budget addition and key rotation to ensure sufficient privacy budget and non-expired keys.

[0111] In one embodiment, in the measured scenario, after five hospital nodes submit commitments, the threshold decryption takes 0.8 s, the reputation weighted aggregation takes 15 ms, and the causal correction matrix inference runs on the side-chain GPU for 240 ms. The current value of the concept drift index data, 0.14, exceeds the threshold of 0.12, and the budget balance ratio of 28% is lower than the lower limit of 30%. The contract automatically adds a budget and generates a new phase angle vector. The next block header broadcasts the shard hash, and the proof process can complete the closed loop within one minute, providing an updated model and key environment for the next round of training.

[0112] Preferably, the reputation weight data is recursively updated by the extended Kalman filter according to the state vector data and the previous round of reputation weight data, and is normalized after the update for weighting the decrypted gradient data.

[0113] In the aggregation stage of the distributed ledger library of the present invention, in order to dynamically evaluate the gradient quality of each participant, an extended Kalman filter is introduced to recursively calculate the reputation weight data. Different from common empirical weighting, the Kalman filter uses state estimation theory, regards "gradient magnitude" and "model error" as observables, and performs Bayesian update on the reputation, which can adaptively suppress the influence of malicious or low-quality nodes.

[0114] Let represent the training round, and define the state variable for the th node:

[0115] where represents the non-normalized value of the reputation weight. Let the observation vector:

[0116] represents the gradient in the coding domain; represents the local mean square error vector.

[0117] The state transition model adopts a random walk:

[0118] The observation model is set as a linear mapping:

[0119] where, is a two-dimensional unit column vector; and They are process noise and observation noise respectively, and the covariance is adaptively estimated by tensor correlation statistics on the chain. The filter performs two steps of "prediction - correction" and outputs the posterior estimate. For use in gradient weighting, normalization is then performed:

[0120] That is, the reputation weight data, which satisfies:

[0121] In practical applications, the process noise is adaptive, and the consensus node automatically adjusts according to the reputation variance of the previous round , enhancing the robustness in the oscillation stage. For the observation noise covariance, the variance of the two - norm of the encoded gradient is taken as the first dimension, and the variance of the one - norm of the error is taken as the second dimension to ensure comparability at different scales. For boundary clipping, if the filtered output is lower than 0.1, it is truncated to 0.1 to avoid information loss caused by the node weight dropping to zero. It is verifiable on the chain, and each aggregated transaction is written with a hash, and external auditors can perform consistency verification by replaying the filtering process on the side chain.

[0122] Through the solution of the present invention, when a certain node uploads an abnormal - noise gradient, its observation residual increases, and the Kalman gain automatically reduces the weight to protect the global model from being dragged down. The reputation evolution considers past errors, is smoother than pure instantaneous scores, and reduces large - scale oscillations. The normalized weights intuitively reflect the contribution ratio of each node to the model increment.

[0123] In one embodiment, in an experiment with five nodes in one round, the initial trust values are all 0.5. Node 3 uploads distorted gradients, resulting in the observation residual being higher than twice the mean. After filtering, the weight of this node drops to 0.12, and its linear coefficient in the global update is compressed to 0.08 with normalization. In the next round, Node 3 corrects the training process, the error drops, and the Kalman gain automatically raises its weight to 0.21. The experimental results verify the immediacy and self - healing of the reputation weight data for weighting differential gradient data.

[0124] Preferably, the causal correction matrix data is obtained by performing causal inference on the decrypted gradient data and label statistical information through a structural equation model, and the causal correction matrix data is stored on the side chain after symmetric encryption.

[0125] In cross-institutional joint training, the gradients uploaded by each node often contain potential confounding factors, such as differences in population distribution, sampling preferences, etc. Without correction, the global model is prone to bias. To solve this problem, the present invention executes a Structural Equation Model (SEM for short) within the side chain of the distributed ledger library to perform causal inference on the decrypted gradient tensor and label statistical information, output causal correction matrix data, and write it into the side chain after symmetric encryption for subsequent gating vector calculation calls.

[0126] Decrypted gradient tensor Can be regarded as the reverse signal of the input feature to the loss function; label statistical information Then reflects the true output distribution. By establishing a Directed Acyclic Graph (DAG) of both with potential confounding variables The "causal contribution" and "confounding contribution" can be explicitly separated. The inferred intervention effect matrix is denoted as causal correction matrix data , and the main diagonal elements of the matrix are used for the subsequent gating mechanism. Mathematically described, let Represent the feature gradient vector (linearized by ), Represent the label vector. Represent the unobserved confounding variable. The structural equation of SEM is written as:

[0127]

[0128] Where Represents the direct effect matrix of the gradient on the label; And Are confounding path coefficient matrices; Represents independent error. According to do-calculus, the intervention effect on Can be obtained:

[0129] Use the least squares unconstrained NOTEARS method to solve the adjacency matrix, and then extract Generate . If The dimension is , only retain the main diagonal vector To participate in the gating vector calculation. After encryption and side chain storage to generate , use AES-256-GCM to encrypt with the session key :

[0130] Key Negotiated by consensus nodes through Diffie-Hellman sessions. Ciphertext Upload to IPFS, and return the content address CID_C. The main chain only records the hash and access control policy, without saving the plaintext.

[0131] Through the solution of the present invention, explicit de-mixing, matrix Provide element-level compensation coefficients, and the gating layer can cancel the mixing effect in real time. Low computational overhead, the average time consumption is 0.24s when the NOTEARS is solving online, and it can be embedded in the block interval. Privacy and security, symmetric encryption and IPFS content addressing ensure that the correction matrix cannot be read without authorization, while reducing the amount of data on the chain. In one embodiment, in a joint financial-medical experiment, the decryption gradient dimension

[0132] In one embodiment, in a joint financial-medical experiment, the decryption gradient dimension The side-chain GPU converges after 30 iterations with NOTEARS to obtain The Frobenius norm of is 5.6. The maximum value of the diagonal is 0.17, indicating that the highest causal contribution does not exceed 17% of the original gradient. The size of the encrypted ciphertext is 16,512 bytes, and CID_C = Qm...ab is obtained through IPFS. The main chain successfully records CID_C and is retrieved and used by the gating vector in the next round of training, verifying the timeliness and security of the causal correction matrix data.

[0133] Preferably, when the concept drift index data exceeds the preset threshold and the balance of the privacy budget token data is lower than the preset ratio, the distributed ledger library appends the privacy budget token data and synchronously rotates the reversible tensor hash key data.

[0134] The federated learning process lasts for weeks or even months, and the label distribution and feature statistics slide over time. If the differential privacy budget and the reversible tensor hash key set in the early training are not updated for a long time, it will lead to insufficient budget and unable to continue perturbing the gradient; the same phase angle vector Being reused increases the side-channel risk. The present invention uses the concept drift index data for adaptive triggering: when a significant distribution drift is detected and the balance is insufficient, the privacy budget tokens are automatically appended and the keys are synchronously rotated.

[0135] The recent window label distribution And the long-term window label distribution The deviation of is measured by KL divergence:

[0136] represents the concept drift index data. Index represents the current on-chain aggregation round. The system maintains the threshold And the lower limit of the budget ratio If all of the following conditions are met simultaneously:

[0137] it is considered that "the data distribution has significantly drifted and the budget is nearly exhausted", and immediate intervention is required. Among them represents the current balance of the privacy budget token; represents the total differential privacy budget; is usually set to 0.30.

[0138] Budget replenishment algorithm, and the additional amount follows a linear compensation strategy:

[0139] is the compensation ratio coefficient, a parameter for on-chain governance. The contract writes into the ERC-3525 semi-fungible token contract in the same transaction to obtain the updated balance:

[0140] The event BudgetTopUp(tokenId, ΔE, blockHeight) enters the block to ensure that the external audit can trace the fund flow.

[0141] Key rotation process. To weaken the risk of statistical attacks brought by key reuse, the reversible tensor hash key is rotated immediately after the budget is replenished. The consensus node uses the latest block hash as a seed, through a pseudo-random function:

[0142] to generate a new phase angle vector . Subsequently, the Shamir sharding method is used to split the key and distribute five pieces to different nodes. The old key pieces are marked as expired and no longer accept training requests. The key rotation event KeyRotate(tokenId, hash(θ^{(t + 1)})) is recorded on the chain so that any training node can retrieve the latest key status.

[0143] Through the solution of the present invention, the additional budget prevents training interruption and ensures that the differential privacy noise always satisfies constraints. It is triggered only when the data distribution changes significantly, avoiding budget waste caused by frequent coin issuance. Each rotation generates a brand-new , reducing the phase side-channel and statistical replay attack surfaces. Both the budget increase and key rotation are written into the event log and are publicly verifiable.

[0144] In one embodiment, it is detected in the 135th round of the chronic disease prediction federated experiment that:

[0145] Contract calculation , the balance rebounds to after supplementary budget. Release a new key hash within the same block . Before the start of the next training round, each node retrieves and downloads the corresponding key slice from the chain to ensure the continuity and consistency of the subsequent reversible tensor hash encoding encryption domain. The measured rotation overhead is less than 250ms.

[0146] As Figure 3 shown, at the operator side, combine the second model fragment parameter data with the first model fragment parameter data to form complete model data. Generate a gating vector based on the causal correction matrix data and the reputation weight data to obtain disease risk prediction data. Write the hash value of the prediction data into the distributed ledger library, and upload the model error information for the next round of training after obtaining the true label.

[0147] At the operator side, after the aggregated second model fragment parameter data is downloaded through a secure channel, it is concatenated with the first model fragment parameter data held locally to obtain the complete neural network weights . The concatenation method maintains hierarchical correspondence to ensure the consistency of gradient accumulation.

[0148] Model concatenation, avoiding exposing the full weights on the chain and only merging the fragments in a local trusted environment; gating modulation, using the causal correction matrix data and the reputation weight data to calculate the gating vector, perform element-wise scaling on the output of the decision layer to weaken potential confounding; result hashing, after outputting the disease risk prediction, only upload the hash value to the chain to protect patient privacy; error backfilling, wait for the true label to arrive, then encrypt and upload the error for use as the observation of the next round of reputation filter.

[0149] The complete model propagates forward the patient features to output the original log-odds vector:

[0150] where represents the input features. The gating vector is generated from the causal correction matrix data and the trust weight data:

[0151] represents the -th diagonal element of the matrix ; represents the -th component of the trust weight data; represents the Sigmoid function. Multiply element-wise to the output:

[0152] Then, through Sigmoid, disease risk prediction data is obtained:

[0153] Select SHA-3-256 to calculate the hash value:

[0154] represents the hash value of the prediction data; represents the one-way hash function SHA-3-256.

[0155] The transaction WritePred(tokenId, h) writes to the distributed ledger library. Since only the hash is uploaded, the specific risk score of the patient is not included on the chain.

[0156] When the true label is obtained, the mean squared error is calculated locally:

[0157] represents the model error information; represents the number of samples.

[0158] The error information is encrypted using AES-256-GCM and uploaded with the transaction UploadErr(tokenId, Enc(e)) for the next round of updating the reputation by the extended Kalman filter.

[0159] Through the solution of the present invention, the gating vector precisely adjusts each output dimension, so that the components greatly affected by causal bias are automatically compressed; only the hash and encrypted error are saved on the chain, without any predicted value or label that can be reverse-inferred for the patient; the error backfill drives the recursive derivation of the reputation weight data, prompting the model to continuously adaptively optimize in a dynamic environment; the hash value is constantly 32 bytes, and the error ciphertext grows linearly with the sample size but has been compressed, adapting to the scenario with limited bandwidth.

[0160] In one embodiment, for batch inference of 500 patients, the complete model output dimension is 323232. After gating, the highest risk score is reduced from 0.82 to 0.67, indicating that the high-confounding components are successfully suppressed. Hash value:

[0161] is recorded with the block height 7,410. After three days, the laboratory follow-up label is obtained, and the error is calculated 。The length of the encrypted ciphertext is 48 bytes. Replay on the chain shows that the transaction is valid and triggers reputation updates, verifying the executability of the gated-hash-feedback chain in real business scenarios.

[0162] Preferably, the gating vector is obtained by element-wise multiplication of the diagonal elements of the causal correction matrix data and the reputation weight data, followed by conversion through a smooth activation function. The gating vector is used to modulate the output of the complete model data.

[0163] The present invention introduces a gating vector mechanism at the operator side, which element-wise modulates the output of the complete model using causal correction matrix data and reputation weight data, aiming to weaken the bias caused by potential confounding and dynamically allocate output contributions according to the credibility of each node.

[0164] Causal correction matrix data The main diagonal elements describe the direct intervention effect between the decryption gradient tensor and the label; the reputation weight data characterize the credible contributions of each feature dimension in the joint model. When they are multiplied element-wise, a combined weight can be obtained, which is then mapped to the interval through a smooth activation function to form the gating vector . The gating vector applies a scaling to the output of the complete model, thereby correcting the bias in real-time and suppressing low-reputation signals during the inference phase.

[0165] Let represent the original log-odds vector of the complete model; represent the reputation weight data; be the causal correction matrix data, and . The gating vector is obtained through two-step calculation:

[0166] where represents the combined weight; represents the -th dimension of the gating vector; represents the smooth activation function, and in this embodiment, the Sigmoid function is selected; is the temperature parameter used to adjust the slope of the gating curve.

[0167] The gating vector acts on the output:

[0168] and then, through Sigmoid or Softmax (depending on the task), the disease risk prediction data .

[0169] The steps for actual application execution include: The operating agency reads the causal correction matrix data hash from the main chain, obtains the ciphertext through the side-chain API and decrypts it locally; at the same time, it reads the latest reputation weight data. Calculate the gating vector according to the above formula in the trusted execution environment, and the temperature parameter is fixed by the governance contract. Multiply the gating vector element by element to the decision layer log odds to obtain the corrected . Perform SHA-3-256 calculation on , and output the hash to write to the transaction WritePred. After the true label arrives, calculate the error locally and encrypt and upload it for the next round of reputation update.

[0170] Through the solution of the present invention, when the causal contribution of a certain feature is low, the gating automatically reduces its impact on the final prediction and reduces bias. The reputation weight reflects the information quality of previous rounds. The gating vector suppresses low-reputation dimensions in real time to prevent malicious gradient amplification. The smooth activation function ensures that the gradient is differentiable and there is no hard threshold jump, which is friendly to training. Only the prediction hash is stored on the chain, and the patient risk score is not exposed.

[0171] In one embodiment, in the asthma acute attack prediction task, the maximum value of the diagonal element of the causal correction matrix , and the corresponding feature is "recent respiratory rate". The reputation weight . Let , and the calculation of the gating component is as follows:

[0172] Compared with the ungated model, the contribution of this feature to the output is reduced by 34%. The experimental results show that the AUC after correction is increased by 1.8%, verifying the effective suppression of bias by the gating vector.

[0173] As Figure 4 shown, a health data processing system based on a distributed ledger library is used to implement the health data processing method based on the distributed ledger library. The system includes: A summary registration module for serializing the first health data and calculating summary data, and submitting the summary data to the distributed ledger library to obtain privacy budget token data and reversible tensor hash key data; the summary registration module (edge node) deploys an x86-64 server supporting the AES-NI instruction set in the hospital private computer room, with dual gigabit network cards directly connected to the blockchain node. The CPU is responsible for UTF-8 serialization and SHA-256 hash calculation; the TPM2.0 chip integrated on the server motherboard is used to save the on-chain identity key and start the TLS1.3 channel, and write the 32-byte summary to the distributed ledger library. The random number calls the built-in RDRAND instruction of the processor to provide an entropy source for the differential privacy budget coinage transaction.

[0174] The encoding training module is used to load reversible tensor hash key data, perform reversible tensor hash encoding on the first model fragment parameter data, complete local training based on the first health data to generate differential gradient data, inject noise into the differential gradient data according to the privacy budget token data to obtain differentially protected gradient data, and generate encrypted commitments and zero-knowledge proof data and then write them into the distributed ledger library, while deducting the privacy budget token data; The encoding training module (encrypted computing node) configures a rack server with NVIDIA A30 GPUs and AMD EPYC processors, and the motherboard integrates an SGX or SEV-ES trusted execution environment. GPU accelerates forward-backward propagation; The AVX-512 VFMA vector instruction of the CPU implements reversible tensor hash encoding. The hardware random number generator generates Gaussian noise and writes it into the GPU HBM. After noise superposition, EPYC completes elliptic curve multiplication within the SEV protection to generate Pedersen commitments, and then calls the PCIe 4.0 network card to push the commitments and zero-knowledge proofs to the ledger nodes, while decreasing the privacy budget tokens through the RDMA asynchronous channel.

[0175] The aggregation and update module is used to decrypt the encrypted commitment to obtain decrypted gradient data after the distributed ledger library verifies the zero-knowledge proof data, generate the second model fragment parameter data based on the reputation weight, infer the causal correction matrix data, and update the balance of the privacy budget token data and rotate the reversible tensor hash key data according to the concept drift index; The aggregation and update module (consensus node cluster) arranges five bare machines based on the ARM Neoverse N2 processor in the data center, and is equipped with a PCle plug-in HSM to save the threshold private key. The multi-party threshold decryption operation is jointly completed by the HSM, and the decrypted gradient then enters the CPU L3 cache, and the second model fragment is generated by weighted summation with the SVE512 instruction. The causal correction operation executes the NOTEARS algorithm on the supporting A100 GPU. The NVMe-oF array of the node records the concept drift index and triggers the internal PRNG of the HSM to generate a new phase angle key, and then distributes the key shards using the IPMI link.

[0176] The inference feedback module is used to combine the second model fragment parameter data and the first model fragment parameter data at the operation institution side to form complete model data, calculate the gating vector based on the causal correction matrix data and the reputation weight data to obtain disease risk prediction data, write the hash value of the disease risk prediction data into the distributed ledger library, and upload the model error information for the next round of training after obtaining the true label. The inference feedback module (operation institution inference server) uses an inference machine with dual Intel Sapphire Rapids CPUs and an RTX 6000 Ada GPU. The CPU splices the two segments of weights within SGX and loads the causal correction matrix and the reputation weight; the GPU performs half-precision inference to obtain the logit vector, and then calculates the gating vector through AVX-512ER and performs an element-wise product. The completed risk score is immediately hashed by the CPU using SHA-3-256, and only the 32-byte result is uploaded to the chain. The true label is directly sent from the hospital HIS system to the inference machine through a 10GbE optical fiber, and the error is encrypted and then uploaded through the blockchain gRPC interface for the next round of learning.

[0177] The above hardware partitioning ensures high throughput and low latency while always restricting private data and keys within the trusted chip boundary, meeting the compliance and performance requirements in the medical scenario.

[0178] Those skilled in the art should understand that the embodiments of the present application can be provided as a method, a system, or a computer program product. Therefore, the present application can adopt the form of a complete hardware embodiment, a complete software embodiment, or an embodiment combining software and hardware aspects.

[0179] The above are only the embodiments of the present application and are not used to limit the present application. For those skilled in the art, various changes and modifications can be made to the present application. Any modification, equivalent replacement, improvement, etc. made within the spirit and principle of the present application shall be included within the scope of the claims of the present application.

Claims

1. A health data processing method based on a distributed ledger library, characterized in that: include: Serialize the first health data and calculate summary data, and submit it to the distributed ledger library to obtain privacy budget token data and reversible tensor hash key data; Using the key to perform reversible tensor hash encoding on the first model segment parameter data, obtaining differential gradient data based on the first health data training, injecting noise into the differential gradient data according to the privacy budget to form differential protection gradient data, generating encrypted commitment and zero-knowledge proof data and writing them into the distributed ledger library, and deducting the privacy budget token data at the same time; The distributed ledger library verifies the zero-knowledge proof data and decrypts the encrypted commitment to obtain the decrypted gradient data, generates the second model segment parameter data based on the reputation weight, infers the causal correction matrix data, and updates the privacy budget token data balance and reversible tensor hash key data based on the concept drift index; At the operating organization end, the second model fragment parameter data is combined with the first model fragment parameter data to form complete model data, and a gating vector is generated based on the causal correction matrix data and the reputation weight data to obtain disease risk prediction data. The hash value of the prediction data is written into the distributed ledger library, and after obtaining the true label, the model error information is uploaded for the next round of training.

2. The method according to claim 1, characterized in that The summary data is obtained by calculating a one-way secure hash algorithm, and the output length of the one-way secure hash algorithm is fixed and can uniquely identify the first health data.

3. The method according to claim 1, characterized in that The noise is Gaussian noise with a mean of zero, and the noise variance is calculated and determined according to the second norm of the differential gradient data and the single-step privacy budget value combined with the differential privacy algorithm.

4. The method according to claim 1, characterized in that: Zero-knowledge proof data is generated through a polynomial commitment-based zero-knowledge proof protocol, and the verification process of the polynomial commitment-based zero-knowledge proof protocol is executed on the consensus node of the distributed ledger library.

5. The method according to claim 1, characterized in that The encrypted commitment is generated by the elliptic curve Pedersen commitment algorithm, which uses random factors output by a hardware random number generator. The encrypted commitment value remains tamper-proof after being written to the distributed ledger library.

6. The method according to claim 1, characterized in that The reputation weight data is recursively updated by the joint Kalman filter based on the state vector data and the previous round of reputation weight data, and is normalized after the update for use in weighting the decryption gradient data.

7. The method according to claim 1, characterized in that The causal correction matrix data is obtained by performing causal inference on the decrypted gradient data and label statistical information through the structural equation model. The causal correction matrix data is stored in the side chain after symmetric encryption.

8. The method according to claim 1, characterized in that When the concept drift index data exceeds the preset threshold and the balance of the privacy budget token data is lower than the preset ratio, the distributed ledger library appends the privacy budget token data and synchronously rotates the reversible tensor hash key data.

9. The method according to claim 1, characterized in that: The gating vector is obtained by multiplying the diagonal elements of the causal correction matrix data by the credit weight data element by element and then converted by a smoothing activation function. The gating vector is used to modulate the output of the complete model data.

10. A health data processing system based on a distributed ledger library, used to implement the health data processing method based on a distributed ledger library according to any one of claims 1 to 9, characterized in that: The system includes: A summary registration module, used to serialize the first health data and calculate summary data, and submit the summary data to the distributed ledger library to obtain privacy budget token data and reversible tensor hash key data; An encoding training module, used to load reversible tensor hash key data, perform reversible tensor hash encoding on the first model segment parameter data, complete local training based on the first health data to generate differential gradient data, inject noise into the differential gradient data according to the privacy budget token data to obtain differential protection gradient data, and generate encrypted commitment and zero-knowledge proof data and write them into the distributed ledger library, while deducting the privacy budget token data; An aggregation update module, which is used to decrypt the encrypted commitment to obtain the decrypted gradient data after verifying the zero-knowledge proof data in the distributed ledger library, generate the second model segment parameter data according to the reputation weight, infer the causal correction matrix data, and update the privacy budget token data balance and the rotation reversible tensor hash key data according to the concept drift index; The inference feedback module is used to combine the second model fragment parameter data with the first model fragment parameter data to form complete model data at the operating organization end, calculate the gating vector based on the causal correction matrix data and the reputation weight data to obtain the disease risk prediction data, write the hash value of the disease risk prediction data into the distributed ledger library, and upload the model error information after obtaining the real label for use in the next round of training.

Images