A probabilistic verifiable computation framework and a verification strategy generation method and system thereof

Abstract

The present application relates to a kind of probabilistic verifiable computing framework and its verification strategy generation method and system, comprising: the characteristic parameter of acquisition computing node, and the preprocessed characteristic parameter is constructed as data set;Trust evaluation model is built, and optimization is carried out using particle swarm optimization algorithm;Optimal parameter combination is used to train trust evaluation model, and the local trust score of trained trust evaluation model is output;Local trust score is corrected using prior knowledge, global trust score is calculated, and consistency verification is carried out on global trust score by consensus synchronization;Final verification probability is calculated;According to final verification probability and global trust score, select appropriate verification mode;Computing node real-time query verification mode, when triggering update condition, recalculate final verification probability, update verification mode;According to the selected verification mode, the verification of computing task is carried out, and abnormal handling is carried out according to verification failure.

Description

Technical Field

[0001] This invention relates to a probabilistic verifiable computing framework and a method and system for generating verification strategies, belonging to the field of computing power system security technology. Background Technology

[0002] Computing networks have become a core infrastructure of the digital economy. Cross-domain scheduling of computing tasks and collaborative execution of heterogeneous nodes are becoming the norm. Ensuring the authenticity and validity of computing results from nodes with different levels of trust has become a key issue in the industry. Currently, mainstream verifiable computing technologies fall into two main categories: cryptographic proof-based technologies, represented by zero-knowledge proofs (ZKP) and homomorphic encryption (HE), can construct computational integrity proofs through mathematical logic, but the computational complexity of proof generation and verification is extremely high, failing to meet the real-time requirements of industry; static strategy-based technologies adopt a binary model of "full verification" or "no verification," such as the periodic full hash comparison of data in cloud computing platforms to achieve data integrity verification. Applying this to the verification of computing results can lead to a decrease in node CPU utilization. Some edge computing solutions abandon verification in pursuit of performance, relying on the reputation and guarantee of node vendors. However, in critical fields such as power and finance, this is difficult to implement due to the risk of result tampering. Existing technologies have significant shortcomings. Performance and security require trade-offs. The overhead of cryptographic proof technology increases exponentially with task complexity, while static strategies are prone to over-verification at the expense of performance or abandonment of verification at the expense of security. There is a lack of trust gradient adaptation capabilities, and differentiated strategies are not designed for the differences in node trust levels in the computing power system. This results in high-trust nodes performing high-frequency verification, wasting resources, while low-trust nodes performing low-frequency verification cannot intercept tampering. There is insufficient compatibility with heterogeneous environments, and the hardware differences between edge nodes and cloud nodes are not adapted, which can easily lead to edge node downtime or cloud node performance waste. The context awareness capability is weak, and strategies are not adjusted according to information such as task criticality and data sensitivity, often resulting in "over-security" or "under-protection". Summary of the Invention

[0003] To address the shortcomings of existing technologies, this invention provides a probabilistic verifiable computing framework and its verification strategy generation method and system. It breaks the rigid "all or nothing" constraint of traditional verifiable computing and constructs a dynamic correlation mechanism of "trust level - verification strength". By setting a trust threshold and combining task context information (such as task criticality and data sensitivity) and node hardware capabilities, the system automatically triggers the verification process with a certain probability and adjusts the verification mode and frequency, ultimately achieving an on-demand balance between security protection and computing performance.

[0004] Terminology Explanation: 1. Blockchain Distributed Ledger Technology (DLT): refers to a ledger system that is jointly maintained, shared and synchronized by multiple nodes. Ledger data is no longer stored by a single central institution, but is distributed and stored on various nodes in the network, and data consistency and immutability are guaranteed through a consensus mechanism.

[0005] 2. IPFS (InterPlanetary File System): This is a content-addressed peer-to-peer (P2P) distributed file storage system that achieves decentralized storage, sharing, and efficient distribution of files by having multiple nodes in the network jointly store and transmit data.

[0006] 3. Practical Byzantine Fault Tolerance (PBFT): This is a consensus algorithm based on state machine replication. Each replica of the state machine stores the complete state of the service and executes legitimate client requests in a consistent order. Under the premise of satisfying the liveness and security requirements of the distributed system, PBFT can tolerate a maximum of f = ⌊(n-1) / 3⌋ Byzantine node failures (including node crashes, failures, or malicious behavior) with a total of n nodes and n ≥ 3f + 1, ensuring that the system can still correctly achieve distributed consensus.

[0007] 4. Zero-Knowledge Proof Algorithm: This is a general term for a class of cryptographic algorithms and protocols used to enable the prover to prove the correctness of a proposition or calculation result to the verifier without revealing any secret information.

[0008] The technical solution of the present invention is as follows: The first aspect of this invention provides a probabilistic verifiable computation framework and a method for generating verification strategies thereon, comprising: Step 1: Collect the feature parameters of the computing nodes, perform preprocessing, and construct a dataset from the preprocessed feature parameters; Step 2: Construct a trust assessment model and optimize it using the particle swarm optimization algorithm to obtain the optimal parameter combination; The trust assessment model is trained using the optimal parameter combination to obtain a trained trust assessment model, and the local trust score is output using the trained trust assessment model. Step 3: Use prior knowledge to correct the local trust score, calculate the global trust score, and verify the consistency of the global trust score through consensus synchronization; Step 4: Calculate the final verification probability based on the global trust score; select the appropriate verification mode based on the final verification probability and the global trust score. Step 5: The compute node queries the verification mode in real time. When the update condition is triggered, the final verification probability is recalculated and the verification mode is updated. The computation task is verified according to the selected verification mode, and exception handling is performed in case of verification failure.

[0009] According to a preferred embodiment of the present invention, step 1 specifically includes the following steps: A data acquisition agent is deployed in each computing node to collect characteristic parameters of the computing node's running status and computing behavior, and uploads them to the blockchain distributed ledger in real time; at the same time, the authenticity of the characteristic parameters is automatically verified by smart contracts, and stored in the IPFS distributed storage system after verification. The collected feature parameters include: historical calculation accuracy, frequency of abnormal behavior, number of offline timeouts, task completion rate, result consistency deviation, security protocol compliance, access control effectiveness, vulnerability remediation timeliness, resource response latency, computing power stability coefficient, memory scheduling efficiency, and storage read / write reliability. Among them, historical calculation accuracy represents the percentage of times that the output of a computing node in a computing task is consistent with the benchmark verification result; Abnormal behavior frequency indicates the number of result error warnings triggered by the computing node within a set timeframe; The offline timeout count represents the number of times a computing node fails to return a calculation result or heartbeat signal within the set time frame as agreed upon in the protocol. Task completion rate represents the percentage of computing tasks received by a computing node that are successfully executed and return results. Consistency deviation represents the average deviation of the output result of a computing node from the consensus result of other computing nodes when the computing node participates in distributed collaborative computing. Security protocol compliance means verifying whether the computing node has enabled the data encryption protocol; Access control validity measures whether the compute node has an access control list configured and whether it restricts access requests from unauthorized IP addresses / accounts. Vulnerability remediation timeliness represents the completion rate of remediation of known high-risk security vulnerabilities within a set timeframe for statistical calculation nodes; Resource response latency represents the average time taken for a computing node to receive a task instruction and return the initial computation result. The computing power stability coefficient represents the fluctuation range of CPU / GPU utilization of statistical computing nodes within a set time period; Memory scheduling efficiency represents the average memory page miss rate of a computing node in a computing task, that is, the proportion of times when the CPU requests memory data that is not in physical memory and needs to be loaded from the disk. Storage read / write reliability represents the percentage of I / O errors that occur during data read / write operations on compute nodes. The feature parameters are weighted using exponential smoothing, as shown below: W t = α×W t-1 + (1-α)×W current ; Among them, W t-1 W represents the weights at time t-1, i.e., the feature parameters after decay processing at time t-1. current W represents the current unadjusted weights. t The adjusted weights are α, where α is the attenuation coefficient. Normalization is used to eliminate differences in characteristic dimensions, as shown below: Z = (W - μ) / σ; Where Z represents the preprocessed feature parameters, W represents the feature parameters after weight adjustment, μ is the mean, and σ is the standard deviation; The presence of malicious behavior on computing nodes is used as a label, which is then combined with preprocessed feature parameters to construct a dataset.

[0010] According to a preferred embodiment of the present invention, step 2 includes the following specific implementation process: The trust evaluation model is an LSTM network model, including an input layer, a hidden layer, and an output layer; The hidden layers of the LSTM network model use the tanh function to handle the nonlinear mapping of temporal features, and the output layer uses the sigmoid function to compress the scores to the 0-1 range. The initial parameters of the LSTM network model are globally optimized using the Particle Swarm Optimization (PSO) algorithm, and then integrated into a particle vector of dimension D. The mean squared error (MSE) of the LSTM network model on the validation set is used as the fitness index, as shown in the formula: Where N is the number of samples in the validation set, y i For real labels, This is a predicted value; Set the particle swarm size, maximum number of iterations, particle velocity range, and position range; randomly initialize the position and velocity of each particle, calculate the initial fitness of each particle, and record the individual optimal position pbest and the global optimal position gbest; update the particle velocity during the optimization process according to the following formula: v j (t+1) = ω×v j(t) + c1×r1×(pbest j - x j (t)) + c2×r2×(gbest j - x j (t)); Where ω is the inertia weight, c1 and c2 are learning factors, r1 and r2 are random numbers in the range [0,1], t is the current iteration number, and x... j Let pbest be the position of particle j. j Gbest represents the optimal position of particle j. j V represents the global optimal position of particle j. j (t+1) represents the updated velocity of particle j at the (t+1)th iteration, v j (t) represents the velocity of particle j in the t-th iteration, x j (t) represents the parameter position vector of particle j at the t-th iteration; the particle position is updated according to the following formula: x j (t+1) = x j (t) + v j (t+1); When the number of iterations reaches the set maximum number of iterations or the global optimal fitness value remains unchanged for consecutive iterations, the optimization stops, and the optimal parameter combination corresponding to gbest is output as the initial training parameters of the LSTM network model. Given a vector sequence X = [x1, x2, ... x...] of length T... t ., x T Input LSTM network model; where x t Let x represent the t-th sequence of data in the dataset. t ∈ R 12 ; Temporal dependencies are captured through the hidden layers of the LSTM network model; The hidden layer output h at the last time step in the LSTM network model. T In the input and output layers, the local trust score S is obtained through linear mapping and sigmoid activation. local The formula is: S local = σ(W h ·h T + b h ); Among them, W h ∈ R 64×1 Let b be the weight matrix. h ∈ R represents the output layer bias, and σ represents the sigmoid function.

[0011] According to a preferred embodiment of the present invention, step 3 specifically includes the following steps: The prior trust probability P (Trust=1), i.e., the prior trust level S, is set according to the computing node type and deployment scenario. prior ; For trusted nodes, S local The mean is μ1, the standard deviation is σ1, and the likelihood probability is: P(S local | Trust=1) = (1 / (2πσ1))·exp(-(S local - μ1)² / (2σ1²)); Wherein, P(S) local | Trust=1) represents the likelihood probability of a trusted node; For untrusted nodes, S local The mean is μ0, the standard deviation is σ0, and the likelihood probability is: P(S local | Trust=0) = (1 / (2πσ0))·exp(-(S local - μ0)² / (2σ0²)); Wherein, P(S) local | Trust=0) represents the likelihood probability of an untrusted node; Calculate the final global trust score S global As shown below: S global = P(Trust=1 | S local ) = [P(S local | Trust=1)·P(Trust=1)] / P(S local ); Where, P(Trust=1 | S local P(Trust=1) represents the posterior probability of a node being trustworthy, and P(S) represents the prior probability of a node being trustworthy. local () represents the marginal probability, as shown below: P(S local ) = P(S local | Trust=1)·P(Trust=1) + P(S local | Trust=0)·P(Trust=0); Where, P(Trust=0) = 1 - S prior ; The global trust score S of the computing node global The node's trust status is submitted to the blockchain distributed ledger; In a blockchain distributed ledger, multiple computing nodes are divided into multiple subarrays. Within each subarray, the global trust score of each computing node is verified for consistency using the Practical Byzantine Fault Tolerance (PBFT) algorithm. When the number of verified computing nodes exceeds the set number, the global trust score within the subarray is aggregated and calculated to generate the corresponding subarray trust score. Each subarray selects a representative node to broadcast the corresponding subarray trust score, and performs consistency verification between subarrays using the Practical Byzantine Fault Tolerance (PBFT) algorithm. All verified consistent subarray trust scores are aggregated to form a unified set of node trust states for the entire network. During broadcasting, aggregate signature technology is used to sign the subarray trust score, which compresses the signatures of N representative nodes into one signature. At set intervals, each subarray submits its trust score, which is then verified for consistency using the Practical Byzantine Fault Tolerance (PBFT) algorithm. The verified subarray trust score is written into the blockchain distributed ledger, which is the unified set of node trust states across the entire network.

[0012] According to a preferred embodiment of the present invention, the final verification probability is calculated based on the global trust score; including: Define a parameter set, including node trust score T, task criticality C, data sensitivity S, and node computing power level P; Wherein, the node trust score T represents the global trust score of the computing node that has passed the consistency verification; Task criticality C indicates the user-specified level of criticality, including three levels: high, medium, and low. Data sensitivity S represents the level of security and privacy risks associated with data involved in a computational task; The node computing power level P is represented by FLOPS and is divided into three levels: weak computing power, medium computing power, and strong computing power. Based on the node trust score T, calculate the basic verification probability, which is the basic threshold minus the node trust score. Based on the task's criticality level C, three levels of criticality weights are set: high, medium, and low. The sensitivity weight is calculated based on the data sensitivity S, and the sensitivity weight is the data sensitivity multiplied by the sensitivity threshold. Based on the node's computing power level P, set computing power weights for weak, medium, and strong computing power; The final verification probability is calculated by combining the above weights and limited to the range of 0.1-1.0. The final verification probability A = max(0.1, min (1.0, A1×A2×A3×A4)); where A1 represents the basic verification probability, A2 represents the critical weight, A3 represents the sensitivity weight, and A4 represents the computing power weight. According to a preferred embodiment of the present invention, selecting a suitable verification mode based on the final verification probability and the global trust score includes: Verification modes include lightweight mode, interactive mode, and full mode; Lightweight mode means: verification is performed once every 10 computation tasks are completed; during verification, the hash value of the final result submitted by the computing node is compared with the reference result or the hash values ​​of the final results submitted by multiple computing nodes to determine whether they are the same. The interactive mode indicates that verification is performed when the completion progress of each computation task reaches 30%, 60%, and 90%. During verification, a simplified zero-knowledge proof algorithm is used, which includes: dynamically dividing the computation task into multiple logical segments according to the execution steps, selecting the execution steps that have a decisive impact on the correctness of the final computation result as the key logical segments, and generating proofs for the key logical segments through the zero-knowledge proof algorithm; using the generated proofs, the zero-knowledge proof algorithm verifies the correctness of the computation process and the computation result. The full-scale mode means that after each computational task is completed, a proof is generated and verified for the entire execution process using a zero-knowledge proof algorithm. Lightweight mode is enabled when the global trust score is greater than 0.8 and the final verification probability is less than 0.3. Interactive mode is enabled when the trust score is between 0.5 and 0.8, or the final verification probability is between 0.3 and 0.7. Otherwise, enable full mode; The generated verification pattern is written into the blockchain distributed ledger via a smart contract.

[0013] According to a preferred embodiment of the present invention, step 5 specifically includes the following steps: The compute nodes query their own corresponding verification mode in real time; when an update condition is triggered, they recalculate the final verification probability and select an appropriate verification mode. Update conditions include: node trust score fluctuations exceeding a set threshold, changes in task parameters, and changes in node computing power level; The computation task is validated according to the selected validation mode. If a single verification fails, a second verification is immediately triggered. At the same time, if the verification mode is lightweight mode, it is upgraded to interactive mode; if it is interactive mode, it is upgraded to full mode. If the second verification passes, the exception is recorded but the node is not penalized. If the second verification fails, the node is judged to be abnormal. If the cumulative number of verification failures exceeds the set threshold within the set period, the node's trust score will be reduced by 0.2, and subsequent tasks will be forced to use the full-scale mode. When the full-scale mode is forced, if the verification fails again within the set time, the computing node will be isolated to the abnormal node pool and prohibited from receiving new tasks. At the same time, an alarm notification will be sent to the system administrator through the smart contract. The administrator will manually review the node status. After the review is passed, the isolation will be lifted and the initial trust score will be restored.

[0014] A computer device includes a memory and a processor, the memory storing a computer program, and the processor executing the computer program implementing the steps of a probabilistic verifiable computation framework and a method for generating verification strategies thereof.

[0015] A computer-readable storage medium having a computer program stored thereon, wherein the computer program, when executed by a processor, implements the steps of a probabilistic verifiable computation framework and a method for generating a verification strategy thereof.

[0016] A second aspect of the present invention provides a probabilistic verifiable computation framework and a verification strategy generation system thereof, comprising: The preprocessing module is configured to: collect feature parameters of computing nodes, perform preprocessing, and construct a dataset from the preprocessed feature parameters; The local trust score calculation module is configured to: construct a trust assessment model and optimize it using a particle swarm optimization algorithm to obtain the optimal parameter combination; The trust assessment model is trained using the optimal parameter combination to obtain a trained trust assessment model, and the local trust score is output using the trained trust assessment model. The global trust score calculation module is configured to: use prior knowledge to correct local trust scores, calculate the global trust score, and verify the consistency of the global trust score through consensus synchronization. The verification mode selection module is configured to: calculate the final verification probability based on the global trust score; and select an appropriate verification mode based on the final verification probability and the global trust score. The verification execution module is configured to: query the verification mode in real time on the compute nodes, and recalculate the final verification probability and update the verification mode when the update condition is triggered; The computation task is verified according to the selected verification mode, and exception handling is performed in case of verification failure.

[0017] The beneficial effects of this invention are as follows: 1. Break the rigid pattern of verifiable computation being "fully verified or not verified at all". By introducing a probabilistic verification mechanism based on node trust scoring, the verification strength can be dynamically adjusted according to the trust level and task risk, significantly reducing unnecessary verification overhead while ensuring security.

[0018] 2. Improve the accuracy and robustness of node trust assessment. By using multi-dimensional feature acquisition, time-series modeling, PSO parameter optimization, and Bayesian inference correction, we can more realistically and stably reflect the long-term and recent behavioral states of nodes, avoiding misjudgments caused by single anomalies or insufficient data.

[0019] 3. Reduce the computing and communication costs of large-scale distributed systems By employing a tiered verification model, critical fragment verification, and a PBFT subarray consensus mechanism, the number of zero-knowledge proof generation operations and consensus communication volume are effectively reduced, thereby improving the overall system operating efficiency.

[0020] 4. Enhance system security and anti-malware capabilities Even if some nodes are faulty or engage in malicious behavior, the consensus mechanism and dynamic verification strategy can still detect anomalies in a timely manner and take isolation measures to ensure the credibility of the computation results.

[0021] 5. It has good scalability and engineering applicability. This invention is applicable to heterogeneous node environments and can flexibly adjust the verification method according to the node's computing power and task requirements. It is easy to deploy and apply in scenarios such as cloud computing, edge computing, and blockchain computing networks. Attached Figure Description

[0022] Figure 1 This is a flowchart of the probabilistic verifiable computation framework and its verification strategy generation method of the present invention. Detailed Implementation

[0023] The present invention will be further described below with reference to the embodiments and accompanying drawings, but is not limited thereto.

[0024] Example 1 A probabilistic verifiable computation framework and a method for generating verification strategies, such as Figure 1 As shown, it includes: Step 1: Collect the feature parameters of the computing nodes, perform preprocessing, and construct a dataset from the preprocessed feature parameters; Step 2: Construct a trust assessment model and optimize it using the particle swarm optimization algorithm to obtain the optimal parameter combination; The trust assessment model is trained using the optimal parameter combination to obtain a trained trust assessment model, and the local trust score is output using the trained trust assessment model. Step 3: Use prior knowledge to correct the local trust score, calculate the global trust score, and verify the consistency of the global trust score through consensus synchronization; Step 4: Calculate the final verification probability based on the global trust score; select the appropriate verification mode based on the final verification probability and the global trust score. Step 5: The compute node queries the verification mode in real time. When the update condition is triggered, the final verification probability is recalculated and the verification mode is updated. The computation task is verified according to the selected verification mode, and exception handling is performed in case of verification failure.

[0025] Example 2 The difference between the probabilistic verifiable computation framework and its verification strategy generation method described in Example 1 is as follows: A data acquisition agent is deployed on each computing node. (The data acquisition agent can run on the computing node as an independent process or container. It obtains the node's computing result verification information, task execution status, resource usage, and security configuration status by calling the operating system interface or computing framework interface, and submits the collected feature parameters to the blockchain network after structured encapsulation.) This agent collects feature parameters of the computing node's running status and computing behavior, and uploads them to the blockchain distributed ledger in real time to achieve data synchronization. At the same time, the authenticity of the feature parameters is automatically verified through smart contracts (a computer protocol that transmits, verifies, or executes contracts in an informational way, verified by timestamps and signatures). After verification, the data is stored in the IPFS distributed storage system to ensure that the data is immutable. Data collection covers three major categories and 12 characteristic parameters: node behavior, security configuration, and resource performance. The collected characteristic parameters include: historical calculation accuracy, frequency of abnormal behavior, number of offline timeouts, task completion rate, result consistency deviation, security protocol compliance, access control effectiveness, vulnerability patching timeliness, resource response latency, computing power stability coefficient, memory scheduling efficiency, and storage read / write reliability. Among them, the historical calculation accuracy rate represents the proportion of times that the output result of the computing node in the last 100 calculation tasks is consistent with the benchmark verification result, reflecting the historical reliability of the node's calculation results, and the value range is [0,1]; the output result represents the result data generated by the computing node based on the received computing task and input data, according to the preset calculation rules; the benchmark verification result represents the reference result for verifying the correctness of the computing node's output result, which is generated by the trusted verification mechanism; The frequency of abnormal behavior represents the number of result error warnings (such as inconsistent hash values, abnormal jumps in intermediate results, etc.) triggered by the computing node within a set time (within the last 24 hours), and the value is a non-negative integer; The offline timeout count represents the number of times a computing node fails to return a calculation result or heartbeat signal within a set period (within the last 24 hours) as agreed in the protocol. It reflects the stability of node communication and operation and takes a non-negative integer value. The task completion rate represents the percentage of computing tasks received by the computing node (the last 50 computing tasks received) that were successfully executed and returned results, excluding task interruptions caused by hardware failures or software crashes. The value range is [0,1]. Consistency deviation represents the average deviation of the output result of a computing node from the consensus result of other computing nodes when the computing node participates in distributed collaborative computing (the consensus result refers to the reference computing result determined from multiple computing results according to the preset consistency rules after multiple computing nodes execute the same computing task in parallel during distributed collaborative computing; such as the absolute error of numerical results and the misclassification rate of categorical results). The value range is [0, +∞). The smaller the deviation, the more stable the node behavior. Security protocol compliance indicates whether the computing node has enabled the data encryption protocol (used for encryption of computing data transmission and storage). It is assigned a value of "enabled = 1, disabled = 0", which reflects the basic data security protection capability of the node. Access control validity indicates whether the compute node has configured an Access Control List (ACL) and whether it restricts access requests from unauthorized IP addresses / accounts. Values ​​are assigned as follows: "Fully Compliant = 1, Partially Compliant = 0.5, Not Compliant = 0". (When the compute node has configured an ACL and effectively restricts access requests from both unauthorized IP addresses and unauthorized accounts, and the relevant access control policies are enabled, it is considered fully compliant and assigned a value of 1. When the compute node only restricts access from at least one of the unauthorized IP addresses or unauthorized accounts, or the access control policies are only effective on some service interfaces or ports, it is considered partially compliant and assigned a value of 0.5. When the compute node has not configured an ACL, or the access control policies are not enabled and cannot effectively restrict unauthorized access requests, it is considered not compliant and assigned a value of 0.) Vulnerability remediation timeliness refers to the completion rate of remediation of known high-risk security vulnerabilities (such as operating system vulnerabilities and computing framework vulnerabilities) on statistical computing nodes within a set period (within the last 30 days). The value range is [0,1] (the higher the remediation rate, the lower the security risk of the node). Resource response latency represents the average time taken for a computing node's task (the last 10 tasks) from receiving the task instruction to returning the initial calculation result, in milliseconds (ms), reflecting the node's task processing efficiency. The computing power stability coefficient represents the fluctuation range of CPU / GPU utilization of statistical computing nodes within a set time (within the last hour). It is calculated by "(maximum utilization - minimum utilization) / average utilization" and the value range is [0,1] (the smaller the coefficient, the more stable the computing power output). Memory scheduling efficiency represents the average memory page miss rate of a computing node in a computing task (last 20 times). That is, when the CPU requests memory data, the required data is not in physical memory and needs to be loaded from the disk. The value range is [0,1] (the lower the miss rate, the more efficient the memory resource scheduling). Storage read / write reliability represents the percentage of IO errors (such as data write failure or corrupted data read) that occur in the last 100 data read / write operations of the record compute node. The value range is [0,1] (the lower the percentage, the stronger the stability of the storage system). The feature parameters are weighted using exponential smoothing, as shown below: W t = α×W t-1 + (1-α)×W current ; Among them, W t-1 W represents the weights at time t-1, i.e., the feature parameters after decay processing at time t-1. current W represents the current unadjusted weights. t The adjusted weights are represented by α, which is the decay coefficient. This emphasizes the impact of node behavior on trust scores within the past hour. If a node shows no abnormalities within the past hour, its weight increases; if an abnormality occurs within the past hour, its weight decreases significantly. Normalization is used to eliminate differences in characteristic dimensions, as shown below: Z = (W - μ) / σ; Where Z represents the preprocessed feature parameters, W represents the feature parameters after weight adjustment, μ is the mean, and σ is the standard deviation, to avoid excessive influence of a single feature on the score; The presence of malicious behavior in computing nodes is used as a label, and the dataset is constructed by combining it with the preprocessed feature parameters (divided into training set (70%), validation set (20%), and test set (10%) in a 7:2:1 ratio).

[0026] If a computing node exhibits malicious behavior (such as result tampering or data forgery) two or more times within 30 days, it is labeled as untrustworthy (label = 0); if no malicious behavior occurs and the historical calculation accuracy is ≥95%, it is labeled as trustworthy (label = 1). Intermediate states are linearly mapped to label values ​​between 0 and 1 based on the frequency of malicious behavior. The specific implementation process of step 2 includes: The trust assessment model is an LSTM network model, including an input layer, a hidden layer, and an output layer; (the number of neurons in each hidden layer of the LSTM is fixed at 64, the number of neurons in the input layer is consistent with the dimension of the feature parameters (i.e., 12, corresponding to the three major categories of features: node behavior, security configuration, and resource performance), and the output layer has 1 neuron (outputting a local trust score)). The hidden layers of the LSTM network model use the tanh function to handle the nonlinear mapping of temporal features, and the output layer uses the sigmoid function to compress the scores to the 0-1 range. The initial learning rate is 0.001 (dynamically adjusted using the Adam optimizer), the batch size is 32, the number of training epochs is 100, and the Dropout coefficient to prevent model overfitting is 0.2. Traditional LSTM models are prone to gradient vanishing during training due to improper initial weight and threshold settings, leading to insufficient learning of temporal features. Therefore, Particle Swarm Optimization (PSO) is used to globally optimize the initial parameters of the LSTM network model. The initial parameters of the LSTM network model (input layer-hidden layer weight matrix, hidden layer-hidden layer weight matrix, hidden layer bias vector, hidden layer-output layer weight matrix, output layer bias vector) are integrated into a particle vector of dimension D, D = (12×64) + (64×64) + 64 + (64×1) + 1 = 4801 (12 is the number of input features, 64 is the number of hidden layer neurons). The mean squared error (MSE) of the LSTM network model on the validation set is used as the fitness index, as shown in the formula: Where N is the number of samples in the validation set, y i For real labels, The fitness value is the predicted value; the smaller the fitness value, the better the parameter combination. Set the particle swarm size (50), maximum number of iterations (30), particle velocity range [-0.5, 0.5], and position range [-1, 1]; randomly initialize the position (initial parameter combination) and velocity of each particle, calculate the initial fitness of each particle, and record the individual optimal position pbest and the global optimal position gbest; update the particle velocity during the optimization process according to the following formula: v j (t+1) = ω×v j (t) + c1×r1×(pbest j - x j (t)) + c2×r2×(gbest j - x j (t)); Where ω is the inertia weight, which decreases linearly from 0.9 to 0.4 with the number of iterations, c1 and c2 are learning factors, r1 and r2 are random numbers in the range [0,1], t is the current iteration number, and x... j Let pbest be the position of particle j. j Gbest represents the optimal position of particle j. j V represents the global optimal position of particle j. j (t+1) represents the updated velocity of particle j at the (t+1)th iteration, v j (t) represents the velocity of particle j in the t-th iteration, x j (t) represents the parameter position vector of particle j at the t-th iteration; the particle position is updated according to the following formula: x j (t+1) = x j (t) + v j (t+1); (If the position exceeds the range [-1,1], it will be forcibly truncated to the boundary). When the number of iterations reaches the set maximum number of iterations (30) or the global optimal fitness value remains unchanged for 5 consecutive iterations, stop the optimization and output the optimal parameter combination corresponding to gbest as the initial training parameters of the LSTM network model. Based on the initial parameters optimized by PSO, an LSTM model is trained to learn the temporal features of node behavior and output a "local trust score" for each node (reflecting the reliability of the temporal behavior of a single node). Given a vector sequence X = [x1, x2, ... x...] of length T... t ., x T Input LSTM network model; where x t Let x represent the t-th sequence of data in the dataset. t ∈ R 12 ; By using the hidden layers (3 hidden layers) of the LSTM network model to capture temporal dependencies, the hidden layer state update formula is as follows: Forgotten Gate: f t = σ(W f ·[h t-1 , x t ] + b f ), determines which historical information to discard, σ is the sigmoid function, W f Let b be the forget gate weight matrix. f To offset the forget gate; Input gate: i t = σ(W i ·[ht-1 , x t ] + b i W decides which new information to update. i Let b be the input gate weight matrix. i For input gate bias; Candidate memory cells: Generate candidate information to be updated, W C Let b be the candidate memory cell weight matrix. C Bias for candidate memory cells; Memory cells: Integrating historical and new information, ⊙ represents the element product; Output gate: o t = σ(W o ·[h t-1 , x t ] + b o W determines which information to output. o Let b be the output gate weight matrix. o For output gate bias; Hidden layer output: h t = o t ⊙tanh(C t ), h t ∈ R 64 , represents the temporal characteristics at time t; The hidden layer output h at the last time step in the LSTM network model. T In the input and output layers, the local trust score S is obtained through linear mapping and sigmoid activation. local The formula is: S local = σ(W h ·h T + b h ); Among them, W h ∈ R 64×1 Let b be the weight matrix. h ∈ R is the output layer bias, σ is the sigmoid function, ensuring S local ∈ [0,1].

[0027] Verify the accuracy of the LSTM network model on the test set. If the model accuracy does not reach the set threshold (test set MSE ≤ 0.05, accuracy (with 0.5 as the threshold, S...)... local If ≥0.5 is considered reliable (≥92%), then readjust the PSO parameters until the performance requirements are met; Step 3 includes the following specific implementation process: Since the local trust score output by the LSTM network model relies solely on the node's own time-series data, it may suffer from issues such as "insufficient data from new nodes" and "random occurrences of abnormal behavior leading to score bias." Therefore, Bayesian inference combined with prior knowledge is introduced to correct the local trust score S. local The final global trust score S is obtained. global ; The prior trust probability P (Trust=1), i.e., the prior trust level S, is set according to the computing node type and deployment scenario. prior ; For example: Enterprise private cloud node (physically isolated, strictly controlled): S prior = 0.9; Cloud-based general-purpose server cluster (standard security protection): S prior = 0.7; Edge terminal node (open access, limited resources): S prior = 0.6; Create a new, non-running node (without historical data): S prior = 0.5 (neutral prior); Likelihood probability P(S) local | Trust) (meaning "if the node is trustworthy, the observed local score S") local The probability of (the probability of) For trusted nodes (nodes with test set label = 1), S local The mean is μ1, the standard deviation is σ1, and the likelihood probability is: P(S local | Trust=1) = (1 / (2πσ1))·exp(-(S local - μ1)² / (2σ1²)); Wherein, P(S) local | Trust=1) represents the likelihood probability of a trusted node; For untrusted nodes (test set label = 0), S local The mean is μ0, the standard deviation is σ0, and the likelihood probability is: P(S local | Trust=0) = (1 / (2πσ0))·exp(-(S local - μ0)² / (2σ0²)); Wherein, P(S) local | Trust=0) represents the likelihood probability of an untrusted node; The LSTM model is trained using the training set; after training, the model's performance is evaluated using the test set, and the local trust score S is calculated based on the samples in the test set. localThe scoring distribution parameters corresponding to trusted and untrusted nodes are statistically analyzed. During actual system operation, the temporal characteristics of the node to be evaluated are input into the trained model, and the corresponding local trust score S is output. local , as the observations for subsequent Bayesian inference; Calculate the final global trust score S global As shown below: S global = P(Trust=1 | S local ) = [P(S local | Trust=1)·P(Trust=1)] / P(S local ); Where, P(Trust=1 | S local P(Trust=1) represents the posterior probability of a node being trustworthy, and P(S) represents the prior probability of a node being trustworthy. local () represents the marginal probability, as shown below: P(S local ) = P(S local | Trust=1)·P(Trust=1) + P(S local | Trust=0)·P(Trust=0); Where, P(Trust=0) = 1 - S prior ; The global trust score S of the computing node global The node's trust status is submitted to the blockchain distributed ledger; In a blockchain distributed ledger, multiple computing nodes are divided into multiple subarrays (each subarray contains 50-100 computing nodes). Within each subarray, the global trust score of each computing node is verified for consistency using the Practical Byzantine Fault Tolerance (PBFT) algorithm. Once the number of verified computing nodes exceeds the set number (2 / 3), the global trust scores within the subarray are aggregated and calculated (e.g., statistical average) to generate the corresponding subarray trust score. Each subarray selects a representative node (based on the current subarray trust score ranking or a round-robin mechanism) to broadcast the corresponding subarray trust score. Consistency verification is then performed among the subarrays using the Practical Byzantine Fault Tolerance (PBFT) algorithm. All verified consistent subarray trust scores are aggregated to form a unified set of node trust states for the entire network. During broadcasting, an aggregate signature technique (such as BLS signature) is used to sign the subarray trust score, compressing the signatures of N representative nodes into a single signature to reduce communication overhead. At set intervals (30 seconds), each subarray submits its trust score, which is then verified for consistency using the Practical Byzantine Fault Tolerance (PBFT) algorithm. The verified subarray trust score is written into the blockchain distributed ledger, forming a unified set of node trust states across the entire network (all compute nodes and their corresponding global trust scores S). global The set of trust states is pushed to the verification policy module in real time via API to ensure that policy generation is based on the latest trust data.

[0028] Calculate the final verification probability based on the global trust score; including: As the decision-making center, it receives multi-dimensional input parameters and outputs precise verification strategies, solving the problem of "how to dynamically adjust verification based on trust levels and task requirements": Define a parameter set, including node trust score T, task criticality C, data sensitivity S, and node computing power level P; Wherein, the node trust score T represents the global trust score (0-1) of the computing node that has passed the consistency verification. Task criticality C represents the criticality level specified by the user, including three levels: high, medium, and low (e.g., gradient updates for large model training are "high", and ordinary log analysis is "low"), which is specified by the user when submitting the task. Data sensitivity (S) represents the security and privacy risk level of data involved in the computing task. It is mapped according to the principles for classifying the importance and risk level of personal information in GB / T 35273-2020 "Information Security Technology - Personal Information Security Specification," specifically including: Level 1: Low-risk data after public or anonymized processing; Level 2: General business data not involving sensitive personal information; Level 3: Data containing identifiable personal information but with controllable risk; Level 4: Data involving important personal information or commercially sensitive information; Level 5: High-risk sensitive data involving financial transactions, biometrics, etc. The node computing power level P is represented by FLOPS (floating-point operations per second) and is divided into three levels: weak computing power (FLOPS < 1e12), medium computing power (1e12 ≤ FLOPS < 1e15), and strong computing power (FLOPS ≥ 1e15). Based on the node trust score T, the basic verification probability is calculated. The basic verification probability is the basic threshold (1.0) minus the node trust score (1.0 - node trust score). The lower the trust level, the higher the probability of triggering verification. Based on the task's criticality level C, three levels of criticality weights are set: high, medium, and low. For example, if the task's criticality level C is high, the criticality weight = 1.2; if the task's criticality level C is medium, the criticality weight = 1.0; and if the task's criticality level C is low, the criticality weight = 0.8 (the more critical the task, the higher the verification intensity is required). The sensitivity weight is calculated based on the data sensitivity S (levels 1-5). The sensitivity weight is the data sensitivity multiplied by the sensitivity threshold (0.2 × data sensitivity). The more sensitive the data, the greater the weight and the higher the verification strength. Based on the node's computing power level P, set computing power weights for weak, medium, and strong computing power; weak computing power nodes (<1e12): weight = 0.8 (reduce verification intensity to avoid resource overload); medium computing power nodes (1e12~1e15): weight = 1.0 (standard verification intensity); strong computing power nodes (≥1e15): weight = 1.1 (can withstand higher verification intensity); The final verification probability is calculated based on the above weights and limited to the range of 0.1-1.0. The final verification probability A = max(0.1, min (1.0, A1×A2×A3×A4)); where A1 represents the basic verification probability, A2 represents the criticality weight, A3 represents the sensitivity weight, and A4 represents the computing power weight. This avoids security risks due to an excessively low verification probability or performance degradation due to an excessively high probability. Based on the final verification probability and the global trust score, select the appropriate verification mode; including: Verification modes include lightweight mode, interactive mode, and full mode; Lightweight mode means: verification is performed once every 10 computation tasks are completed; during verification, the hash value of the final result submitted by the computing node is compared with the reference result or the hash values ​​of the final results submitted by multiple computing nodes to determine whether they are the same. The interactive mode involves verifying the completion progress of each computation task at 30%, 60%, and 90%. During verification, a simplified zero-knowledge proof algorithm is used, including: dynamically dividing the computation task into multiple logical segments according to execution steps (e.g., large model training is divided into segments of "100 gradient updates" or "50 iterations," and log analysis is divided into segments of "1000 log entries"). Execution steps that decisively affect the correctness of the final computation result are selected as key logical segments (e.g., model parameter update nodes, iteration convergence nodes, cross-node data interaction nodes, or state switching nodes). A proof is generated for each key logical segment using the zero-knowledge proof algorithm. Through the generated proof, the zero-knowledge proof algorithm verifies the correctness of the computation process and results. The full-scale mode means that after each computational task is completed, a proof is generated and verified for the entire execution process using a zero-knowledge proof algorithm. Lightweight mode is enabled when the global trust score is greater than 0.8 and the final verification probability is less than 0.3. Interactive mode is enabled when the trust score is between 0.5 and 0.8, or the final verification probability is between 0.3 and 0.7. Otherwise, enable full mode; The generated verification pattern is written into the blockchain distributed ledger via a smart contract to ensure that the strategy cannot be tampered with.

[0029] Step 5 includes the following specific implementation process: Compute nodes (via API) query their own corresponding verification mode in real time; when an update condition is triggered, they recalculate the final verification probability and select an appropriate verification mode. Update conditions include: node trust score fluctuations exceeding a set threshold (0.1), changes in task parameters (referring to characteristics related to the computational tasks that affect the generation of verification strategies, including task criticality, data sensitivity, node computing power level, and other attributes that may affect the verification strategy, such as task type, expected execution time, and task stage; for example, data sensitivity increasing from level 2 to level 4), and changes in node computing power level (such as edge nodes connecting to the cloud computing power pool, with computing power increasing from 5e11 to 2e15). The computation task is validated according to the selected validation mode. If a single verification fails, a second verification is immediately triggered. At the same time, if the verification mode is lightweight mode, it is upgraded to interactive mode; if it is interactive mode, it is upgraded to full mode. If the second verification passes, the exception is recorded but the node is not penalized. If the second verification fails, the node is judged to be abnormal. If the cumulative number of verification failures exceeds the set threshold within a set period (24 hours) (e.g., more than 3 times), the node trust score will be reduced by 0.2 (down to a minimum of 0.1), and subsequent tasks will be forced to use the full-scale mode. When the full-scale mode is forced, if the verification fails again within a set time (e.g., 24 hours), the computing node will be isolated to the abnormal node pool and prohibited from receiving new tasks. At the same time, an alarm notification will be sent to the system administrator through a smart contract. The administrator will manually review the node status (e.g., check for hardware failures, malware, etc.). After the review is passed, the isolation will be lifted and the initial trust score will be restored.

[0030] Example 3 A computer device includes a memory and a processor, the memory storing a computer program, and the processor executing the computer program implementing the steps of a probabilistic verifiable computation framework and a method for generating verification strategies thereof.

[0031] Example 4 A computer-readable storage medium having a computer program stored thereon, wherein the computer program, when executed by a processor, implements the steps of a probabilistic verifiable computation framework and a method for generating a verification strategy thereof.

[0032] Example 5 A probabilistic verifiable computation framework and its verification strategy generation system, comprising: The preprocessing module is configured to: collect feature parameters of computing nodes, perform preprocessing, and construct a dataset from the preprocessed feature parameters; The local trust score calculation module is configured to: construct a trust assessment model and optimize it using a particle swarm optimization algorithm to obtain the optimal parameter combination; The trust assessment model is trained using the optimal parameter combination to obtain a trained trust assessment model, and the local trust score is output using the trained trust assessment model. The global trust score calculation module is configured to: use prior knowledge to correct local trust scores, calculate the global trust score, and verify the consistency of the global trust score through consensus synchronization. The verification mode selection module is configured to: calculate the final verification probability based on the global trust score; and select an appropriate verification mode based on the final verification probability and the global trust score. The verification execution module is configured to: query the verification mode in real time on the compute nodes, and recalculate the final verification probability and update the verification mode when the update condition is triggered; The computation task is verified according to the selected verification mode, and exception handling is performed in case of verification failure.

Claims

1. A probabilistic verifiable computation framework and a method for generating verification strategies thereon, characterized in that, include: Step 1: Collect the feature parameters of the computing nodes, perform preprocessing, and construct a dataset from the preprocessed feature parameters; Step 2: Construct a trust assessment model and optimize it using the particle swarm optimization algorithm to obtain the optimal parameter combination; The trust assessment model is trained using the optimal parameter combination to obtain a trained trust assessment model, and the local trust score is output using the trained trust assessment model. Step 3: Use prior knowledge to correct the local trust score, calculate the global trust score, and verify the consistency of the global trust score through consensus synchronization; Step 4: Calculate the final verification probability based on the global trust score; select the appropriate verification mode based on the final verification probability and the global trust score. Step 5: The compute node queries the verification mode in real time. When the update condition is triggered, the final verification probability is recalculated and the verification mode is updated. The computation task is verified according to the selected verification mode, and exception handling is performed in case of verification failure.

2. The probabilistic verifiable computation framework and its verification strategy generation method according to claim 1, characterized in that, Step 1 includes the following specific implementation process: A data acquisition agent is deployed in each computing node to collect characteristic parameters of the computing node's running status and computing behavior, and uploads them to the blockchain distributed ledger in real time; at the same time, the authenticity of the characteristic parameters is automatically verified by smart contracts, and stored in the IPFS distributed storage system after verification. The collected feature parameters include: historical calculation accuracy, frequency of abnormal behavior, number of offline timeouts, task completion rate, result consistency deviation, security protocol compliance, access control effectiveness, vulnerability remediation timeliness, resource response latency, computing power stability coefficient, memory scheduling efficiency, and storage read / write reliability. Among them, historical calculation accuracy represents the percentage of times that the output of a computing node in a computing task is consistent with the benchmark verification result; Abnormal behavior frequency indicates the number of result error warnings triggered by the computing node within a set timeframe; The offline timeout count represents the number of times a computing node fails to return a calculation result or heartbeat signal within the set time frame as agreed upon in the protocol. Task completion rate represents the percentage of computing tasks received by a computing node that are successfully executed and return results. Consistency deviation represents the average deviation of the output result of a computing node from the consensus result of other computing nodes when the computing node participates in distributed collaborative computing. Security protocol compliance means verifying whether the computing node has enabled the data encryption protocol; Access control validity measures whether the compute node has an access control list configured and whether it restricts access requests from unauthorized IP addresses / accounts. Vulnerability remediation timeliness represents the completion rate of remediation of known high-risk security vulnerabilities within a set timeframe for statistical calculation nodes; Resource response latency represents the average time taken for a computing node to receive a task instruction and return the initial computation result. The computing power stability coefficient represents the fluctuation range of CPU / GPU utilization of statistical computing nodes within a set time period; Memory scheduling efficiency represents the average memory page miss rate of a computing node in a computing task, that is, the proportion of times when the CPU requests memory data that is not in physical memory and needs to be loaded from the disk. Storage read / write reliability represents the percentage of I / O errors that occur during data read / write operations on compute nodes. The feature parameters are weighted using exponential smoothing, as shown below: W t = α×W t-1 + (1-a)×W current ; Among them, W t-1 W represents the weights at time t-1, i.e., the feature parameters after decay processing at time t-1. current W represents the current unadjusted weights. t The adjusted weights are α, where α is the attenuation coefficient. Normalization is used to eliminate differences in characteristic dimensions, as shown below: Z = (W - μ) / σ; Where Z represents the preprocessed feature parameters, W represents the feature parameters after weight adjustment, μ is the mean, and σ is the standard deviation; The presence of malicious behavior on computing nodes is used as a label, which is then combined with preprocessed feature parameters to construct a dataset.

3. The probabilistic verifiable computation framework and its verification strategy generation method according to claim 2, characterized in that, The specific implementation process of step 2 includes: The trust evaluation model is an LSTM network model, including an input layer, a hidden layer, and an output layer; The hidden layers of the LSTM network model use the tanh function to handle the nonlinear mapping of temporal features, and the output layer uses the sigmoid function to compress the scores to the 0-1 range. The initial parameters of the LSTM network model are globally optimized using the Particle Swarm Optimization (PSO) algorithm, and then integrated into a particle vector of dimension D. The mean squared error (MSE) of the LSTM network model on the validation set is used as the fitness index, as shown in the formula: Where N is the number of samples in the validation set, y i For real labels, This is a predicted value; Set the particle swarm size, maximum number of iterations, particle velocity range, and position range; randomly initialize the position and velocity of each particle, calculate the initial fitness of each particle, and record the individual optimal position pbest and the global optimal position gbest; update the particle velocity during the optimization process according to the following formula: v j (t+1) = ω×v j (t) + c1×r1×(pbest j - x j (t)) + c2×r2×(gbest j - x j (t)); Where ω is the inertia weight, c1 and c2 are learning factors, r1 and r2 are random numbers in the range [0,1], t is the current iteration number, and x... j Let pbest be the position of particle j. j Gbest represents the optimal position of particle j. j V represents the global optimal position of particle j. j (t+1) represents the updated velocity of particle j at the (t+1)th iteration, v j (t) represents the velocity of particle j in the t-th iteration, x j (t) represents the parameter position vector of particle j at the t-th iteration; the particle position is updated according to the following formula: x j (t+1) = x j (t) + v j (t+1); When the number of iterations reaches the set maximum number of iterations or the global optimal fitness value remains unchanged for consecutive iterations, the optimization stops, and the optimal parameter combination corresponding to gbest is output as the initial training parameters of the LSTM network model. Given a vector sequence X = [x1, x2, ... x...] of length T... t ., x T Input LSTM network model; where x t Let x represent the t-th sequence of data in the dataset. t ∈ R 12 ; Temporal dependencies are captured through the hidden layers of the LSTM network model; The hidden layer output h at the last time step in the LSTM network model. T In the input and output layers, the local trust score S is obtained through linear mapping and sigmoid activation. local The formula is: S local = σ(W h ·h T + b h ); Among them, W h ∈ R 64×1 Let b be the weight matrix. h ∈ R represents the output layer bias, and σ represents the sigmoid function.

4. The probabilistic verifiable computation framework and its verification strategy generation method according to claim 3, characterized in that, Step 3 includes the following specific implementation process: The prior trust probability P (Trust=1), i.e., the prior trust level S, is set according to the computing node type and deployment scenario. prior ; For trusted nodes, S local The mean is μ1, the standard deviation is σ1, and the likelihood probability is: P(S local | Trust=1) = (1 / (2πσ1))·exp(-(S local - μ1)² / (2σ1²)); Wherein, P(S) local | Trust=1) represents the likelihood probability of a trusted node; For untrusted nodes, S local The mean is μ0, the standard deviation is σ0, and the likelihood probability is: P(S local | Trust=0) = (1 / (2πσ0))·exp(-(S local - μ0)² / (2σ0²)); Wherein, P(S) local | Trust=0) represents the likelihood probability of an untrusted node; Calculate the final global trust score S global As shown below: S global = P(Trust=1 | S local ) = [P(S local | Trust=1)·P(Trust=1)] / P(S local ); Where, P(Trust=1 | S local P(Trust=1) represents the posterior probability of a node being trustworthy, and P(S) represents the prior probability of a node being trustworthy. local () represents the marginal probability, as shown below: P(S local ) = P(S local | Trust=1)·P(Trust=1) + P(S local | Trust=0)·P(Trust=0); Where, P(Trust=0) = 1 - S prior ; The global trust score S of the computing node global The node's trust status is submitted to the blockchain distributed ledger; In a blockchain distributed ledger, multiple computing nodes are divided into multiple subarrays. Within each subarray, the global trust score of each computing node is verified for consistency using the Practical Byzantine Fault Tolerance (PBFT) algorithm. When the number of verified computing nodes exceeds the set number, the global trust score within the subarray is aggregated and calculated to generate the corresponding subarray trust score. Each subarray selects a representative node to broadcast the corresponding subarray trust score, and performs consistency verification between subarrays using the Practical Byzantine Fault Tolerance (PBFT) algorithm. All verified consistent subarray trust scores are aggregated to form a unified set of node trust states for the entire network. During broadcasting, the subarray trust score is signed using aggregate signature technology, which compresses the signatures of N representative nodes into one signature. At set intervals, each subarray submits its trust score, which is then verified for consistency using the Practical Byzantine Fault Tolerance (PBFT) algorithm. The verified subarray trust score is written into the blockchain distributed ledger, which is the unified set of node trust states across the entire network.

5. The probabilistic verifiable computation framework and its verification strategy generation method according to claim 4, characterized in that, Calculate the final verification probability based on the global trust score; including: Define a parameter set, including node trust score T, task criticality C, data sensitivity S, and node computing power level P; Wherein, the node trust score T represents the global trust score of the computing node that has passed the consistency verification; Task criticality C indicates the user-specified level of criticality, including three levels: high, medium, and low. Data sensitivity S represents the level of security and privacy risks associated with data involved in a computational task; The node computing power level P is represented by FLOPS and is divided into weak computing power, medium computing power, and strong computing power. Based on the node trust score T, calculate the basic verification probability, which is the basic threshold minus the node trust score. Based on the task's criticality level C, three levels of criticality weights are set: high, medium, and low. The sensitivity weight is calculated based on the data sensitivity S, and the sensitivity weight is the data sensitivity multiplied by the sensitivity threshold. Based on the node's computing power level P, set computing power weights for weak, medium, and strong computing power; The final verification probability is calculated by combining the above weights and limited to the range of 0.1-1.

0. The final verification probability A = max(0.1, min (1.0, A1 ×A2 ×A3 ×A4)); where A1 represents the basic verification probability, A2 represents the critical weight, A3 represents the sensitivity weight, and A4 represents the computing power weight.

6. The probabilistic verifiable computation framework and its verification strategy generation method according to claim 5, characterized in that, Based on the final verification probability and the global trust score, select the appropriate verification mode; including: Verification modes include lightweight mode, interactive mode, and full mode; Lightweight mode means: verification is performed once every 10 computation tasks are completed; during verification, the hash value of the final result submitted by the computing node is compared with the reference result or the hash values ​​of the final results submitted by multiple computing nodes to determine whether they are the same. The interactive mode indicates that verification is performed when the completion progress of each computation task reaches 30%, 60%, and 90%. During verification, a simplified zero-knowledge proof algorithm is used, which includes: dynamically dividing the computation task into multiple logical segments according to the execution steps, selecting the execution steps that have a decisive impact on the correctness of the final computation result as the key logical segments, and generating proofs for the key logical segments through the zero-knowledge proof algorithm; using the generated proofs, the zero-knowledge proof algorithm verifies the correctness of the computation process and the computation result. The full-scale mode means that after each computational task is completed, a proof is generated and verified for the entire execution process using a zero-knowledge proof algorithm. Lightweight mode is enabled when the global trust score is greater than 0.8 and the final verification probability is less than 0.

3. Interactive mode is enabled when the trust score is between 0.5 and 0.8, or the final verification probability is between 0.3 and 0.

7. Otherwise, enable full mode; The generated verification pattern is written into the blockchain distributed ledger via a smart contract.

7. The probabilistic verifiable computation framework and its verification strategy generation method according to claim 6, characterized in that, Step 5 includes the following specific implementation process: The compute nodes query their own corresponding verification mode in real time; when an update condition is triggered, they recalculate the final verification probability and select an appropriate verification mode. Update conditions include: node trust score fluctuations exceeding a set threshold, changes in task parameters, and changes in node computing power level; The computation task is validated according to the selected validation mode. If a single verification fails, a second verification is immediately triggered. At the same time, if the verification mode is lightweight mode, it is upgraded to interactive mode; if it is interactive mode, it is upgraded to full mode. If the second verification passes, the exception is recorded but the node is not penalized. If the second verification fails, the node is judged to be abnormal. If the cumulative number of verification failures exceeds the set threshold within the set period, the node's trust score will be reduced by 0.2, and subsequent tasks will be forced to use the full-scale mode. When the full-scale mode is forced, if the verification fails again within the set time, the computing node will be isolated to the abnormal node pool and prohibited from receiving new tasks. At the same time, an alarm notification will be sent to the system administrator through the smart contract. The administrator will manually review the node status. After the review is passed, the isolation will be lifted and the initial trust score will be restored.

8. A computer device comprising a memory and a processor, wherein the memory stores a computer program, characterized in that, The steps of implementing a probabilistic verifiable computing framework and a method for generating verification strategies when the processor executes the computer program.

9. A computer-readable storage medium having a computer program stored thereon, characterized in that, The steps of implementing the probabilistic verifiable computing framework and its verification strategy generation method when the computer program is executed by the processor.

10. A probabilistic verifiable computation framework and its verification strategy generation system, characterized in that, include: The preprocessing module is configured to: collect feature parameters of computing nodes, perform preprocessing, and construct a dataset from the preprocessed feature parameters; The local trust score calculation module is configured to: construct a trust assessment model and optimize it using a particle swarm optimization algorithm to obtain the optimal parameter combination; The trust assessment model is trained using the optimal parameter combination to obtain a trained trust assessment model, and the local trust score is output using the trained trust assessment model. The global trust score calculation module is configured to: use prior knowledge to correct local trust scores, calculate the global trust score, and verify the consistency of the global trust score through consensus synchronization. The verification mode selection module is configured to: calculate the final verification probability based on the global trust score; and select an appropriate verification mode based on the final verification probability and the global trust score. The verification execution module is configured to: query the verification mode in real time on the compute nodes, and recalculate the final verification probability and update the verification mode when the update condition is triggered; The computation task is verified according to the selected verification mode, and exception handling is performed in case of verification failure.

Images