CN114693450A - Calculation, update, reading method and device based on smart contract, electronic equipment - Google Patents

Abstract

A computing method based on intelligent contracts, intelligent contracts used for executing approximate computation are deployed on a blockchain, and the method comprises the following steps: receiving an intelligent contract calling transaction aiming at an intelligent contract and initiated by a calculation initiator; the intelligent contract invoking transaction comprises calculation parameters corresponding to the approximate calculation; the calculation parameters comprise data identifications of the data sets participating in the approximate calculation; responding to the intelligent contract call transaction, calling sampling logic contained in the intelligent contract call transaction, dividing a data set corresponding to the data identification into an outlier data subset formed by a plurality of outlier data samples and a non-outlier data subset formed by a plurality of non-outlier data samples, and sampling the non-outlier data samples in the non-outlier data subset; and calling a calculation logic contained in the transaction by using an intelligent contract, performing accurate calculation on the outlier data samples in the outlier data subset, performing approximate calculation on the non-outlier data samples obtained by sampling, and combining the results of the accurate calculation and the approximate calculation.

Description

Calculation, update, reading method and device based on smart contract, electronic equipment

technical field

One or more embodiments of this specification relate to the field of blockchain technology, and in particular, to a computing device and electronic device based on a smart contract.

Background technique

Blockchain is a new application mode of computer technology such as distributed data storage, point-to-point transmission, consensus mechanism, and encryption algorithm. In the blockchain system, the data blocks are sequentially connected to form a chain data structure according to the time sequence, and a distributed ledger that cannot be tampered with and cannot be forged by cryptography. Due to the characteristics of decentralization, non-tampering of information, and autonomy, blockchain has also received more and more attention and applications.

SUMMARY OF THE INVENTION

This specification proposes a computing method based on a smart contract, which is applied to a node device in a blockchain where a smart contract for performing approximate computing is deployed, and the method includes:

Receive a smart contract invocation transaction for the smart contract initiated by a calculation initiator; wherein the smart contract invocation transaction includes a calculation parameter corresponding to the approximate calculation; the calculation parameter includes a data identifier of a data set participating in the approximate calculation ;

in response to the smart contract invocation transaction, invoking the sampling logic included in the smart contract invocation transaction, dividing the data set corresponding to the data identifier into an outlier data subset consisting of a number of outlier data samples, and A non-outlier data subset composed of several non-outlier data samples, and sampling the non-outlier data samples in the non-outlier data subset;

Further invoking the calculation logic included in the smart contract invocation transaction, performing accurate calculation on the outlier data samples in the outlier data subset, and approximating the non-outlier data samples sampled from the non-outlier data subset calculating, and combining the results of the exact calculation and the approximate calculation as an approximate calculation result for the data set.

This specification also proposes a computing device based on a smart contract, which is applied to a node device in a blockchain, where a smart contract for performing approximate calculations is deployed on the blockchain, and the device includes:

a receiving module, for receiving a smart contract invocation transaction for the smart contract initiated by a computing initiator; wherein, the smart contract invocation transaction includes a calculation parameter corresponding to the approximate calculation; the calculation parameter includes a data set participating in the approximate calculation data identification;

The sampling module, in response to the smart contract invocation transaction, invokes the sampling logic included in the smart contract invocation transaction, and divides the data set corresponding to the data identifier into outlier data subsections consisting of a number of outlier data samples set, and a non-outlier data subset composed of several non-outlier data samples, and sample the non-outlier data samples in the non-outlier data subset;

The calculation module further invokes the calculation logic contained in the smart contract invocation transaction, and performs accurate calculation for the outlier data samples in the outlier data subset, and for the non-outlier data sampled from the non-outlier data subset An approximate calculation is performed on the sample, and the results of the exact calculation and the approximate calculation are combined as an approximate calculation result for the data set.

In the above technical solution, in the scenario of invoking a smart contract to perform approximate calculation on a data set, by introducing a sampling mechanism for the data set into the smart contract, the accuracy of the approximate calculation result can be reduced without sacrificing the accuracy of the approximate calculation result. The time-consuming of the approximate calculation for the data set is improved, and the calculation efficiency of the approximate calculation for the data set is improved. Moreover, in the process of performing approximate calculation on the data set, the approximate calculation is not performed after sampling the outlier data in the data set, but the accurate calculation is directly performed without sampling, so that the data set can include outliers. In the case of data, it is further avoided that these outlier data samples affect the accuracy of the approximate calculation result for the data set, and the accuracy of the approximate calculation for the data set can be ensured to the greatest extent.

Description of drawings

1 is a flowchart of a computing method based on a smart contract provided by an exemplary embodiment;

Fig. 2 is a flow chart of an optimization solution method provided by an exemplary embodiment;

3 is a schematic structural diagram of an electronic device provided by an exemplary embodiment;

FIG. 4 is a block diagram of a computing device based on a smart contract provided by an exemplary embodiment.

Detailed ways

Exemplary embodiments will be described in detail herein, examples of which are illustrated in the accompanying drawings. Where the following description refers to the drawings, the same numerals in different drawings refer to the same or similar elements unless otherwise indicated. The implementations described in the exemplary embodiments below are not intended to represent all implementations consistent with one or more embodiments of this specification. Rather, they are merely examples of apparatus and methods consistent with some aspects of one or more embodiments of this specification, as recited in the appended claims.

It should be noted that: in other embodiments, the steps of the corresponding methods are not necessarily performed in the order shown and described in this specification. In some other embodiments, the method may include more or fewer steps than described in this specification. In addition, a single step described in this specification may be decomposed into multiple steps for description in other embodiments; and multiple steps described in this specification may also be combined into a single step in other embodiments. describe.

With the continuous development of smart contract technology, when using smart contracts to connect with businesses, smart contracts have gradually begun to assume part of the computing power related to the business.

For example, in practical applications, the smart contract deployed on the blockchain for docking with the business may include, in addition to the business logic related to the business, the logic for calculating the business data related to the business, Therefore, the user can complete the calculation related to the business on the blockchain by invoking the smart contract.

When a smart contract is used to calculate a business-related data set, the total calculation time usually depends on the time-consuming of performing I/O operations for each piece of data and the time-consuming calculation of the above-mentioned group of data in batches.

For example, in practical applications, taking business-related data sets pre-stored on the blockchain as an example, at this time, the total time spent by smart contracts to calculate business-related data sets can usually be calculated using the following formula to represent:

Wherein, in the above formula, i represents the i-th piece of data in the above-mentioned data set; IO _i represents the time-consuming operation of I/O operation processing operations for the i-th piece of data; Operation _i represents the batch of i pieces of data in the data set The time it takes to perform the calculation.

It should be noted that when the data collection is stored on the blockchain, it is usually stored in the storage medium carried by the blockchain node device in the form of key-value key-value pairs one by one. The above-mentioned data set on the blockchain can usually only be read one by one from the storage medium carried by the blockchain node device according to the key value of the data.

In some application scenarios that require higher privacy and security for data computing, the above smart contracts can also be deployed in a TEE (Trusted execution environment, trusted execution environment) carried on the blockchain node device.

In this case, the data in the above data set usually needs to be encrypted and stored. At this time, when a smart contract is used to calculate a business-related data set, the total calculation time usually depends on the time-consuming of I/O operations for each piece of data and the time-consuming of decrypting each piece of data separately. , and the time-consuming calculation of the above-mentioned set of data in batches.

For example, in practical applications, taking business-related data sets pre-stored on the blockchain as an example, at this time, the total time spent by smart contracts to calculate business-related data sets can usually be calculated using the following formula to represent:

Wherein, in the above formula, Operation _i represents the time-consuming of decrypting the i-th piece of data in the data set.

From the above introduction, it is not difficult to see that in the scenario where smart contracts are used to calculate business-related data sets, if the data set contains a relatively large amount of data, the smart contracts are used to calculate the data set to obtain accurate calculations. The result is very time consuming.

In practical applications, in some business scenarios, accurate calculation results for business-related data may not be required, but some loss of calculation accuracy can be tolerated.

For example, in the calculation scenario of calculating the average age of a user, in most cases, an accurate calculation result is not required, and usually only an approximate calculation is required to obtain an average age interval.

Based on this, this specification proposes a technical solution for introducing approximate calculation and data sampling mechanisms into smart contracts to improve the computational efficiency of business-related data calculations.

When implemented, a smart contract for data computation can be deployed on the blockchain, and the smart contract can contain approximate computation logic for approximate computation and sampling logic for data sampling. The calculation initiator can call the smart contract to perform approximate calculation on the data set participating in the calculation by initiating a smart contract call transaction. Wherein, the smart contract invocation transaction may include a calculation parameter corresponding to the approximate calculation; the calculation parameter may include a data identifier of a data set participating in the approximate calculation;

When receiving the smart contract invocation transaction initiated by the computing initiator, the node device in the blockchain can respond to the smart contract invocation transaction, invoke the sampling logic contained in the smart contract invocation transaction, and store the data corresponding to the data identifier. The data set is divided into an outlier data subset composed of a number of outlier data samples, and a non-outlier data subset composed of a number of non-outlier data samples, and for the non-outlier data subsets in the non-outlier data subset After the sampling is completed, the approximate calculation logic contained in the smart contract can be further called to perform accurate calculation for the outlier data samples in the outlier data subset, and for the outlier data samples from the non-outlier data subset. An approximate calculation is performed on the sampled non-outlier data samples, and the results of the exact calculation and the approximate calculation are combined as an approximate calculation result for the data set.

In the above technical solution, in the scenario of invoking a smart contract to perform approximate calculation on a data set, by introducing a sampling mechanism for the data set in the smart contract, the accuracy of the approximate calculation result can be reduced without sacrificing the accuracy of the approximate calculation result. The time-consuming when the approximate calculation is performed on the data set improves the calculation efficiency when the approximate calculation is performed on the data set.

Moreover, in the process of performing approximate calculation on the data set, the approximate calculation is not performed after sampling the outlier data in the data set, but the accurate calculation is directly performed without sampling, so that the data set can include outliers. In the case of data, it is further avoided that these outlier data samples affect the accuracy of the approximate calculation result for the data set, and the accuracy of the approximate calculation for the data set can be ensured to the greatest extent.

Please refer to FIG. 1 , which is a flowchart of a computing method based on a smart contract provided by an exemplary embodiment. The method is applied to a node device in a blockchain; wherein a smart contract for performing approximate calculations is deployed on the blockchain, and the method includes the following steps:

Step 102: Receive a smart contract invocation transaction for the smart contract initiated by a computing initiator; wherein, the smart contract invocation transaction includes a calculation parameter corresponding to the approximate calculation; the calculation parameter includes a data set participating in the approximate calculation data identification;

The above calculation initiator may specifically be a party with data calculation requirements. For example, in one example, the above computing initiator may be a user with data computing requirements. In another example, in the scenario of docking with a business based on a smart contract, the computing initiator may specifically be an off-chain business system with data computing requirements.

On the blockchain, a smart contract for data calculation can be deployed, and the execution logic corresponding to the contract code contained in the smart contract may specifically include approximate calculation logic for approximate calculation and sampling logic for data sampling . In this way, the logic of approximate calculation of data and data sampling can be introduced into the smart contract.

It should be noted that the sampling method used for the above data sampling is not particularly limited in this specification; for example, random sampling (Random Sampling), Stratified Sampling (Stratified Sampling), etc. may be used.

The above-mentioned calculation initiator can call the above-mentioned smart contract to perform approximate calculation on the data set participating in the calculation by initiating a smart contract invocation transaction.

For example, take the above calculation initiator as the user and the above blockchain as an account model blockchain as an example, in this case, the above smart contract can be understood as an anchored contract code on the blockchain. contract account, and the user can register an external account on the blockchain, initiate a smart contract invocation transaction through the external account, and submit the smart contract invocation transaction to the connected blockchain node device to invoke the smart contracts.

It should be noted that, in the above smart contract invocation transaction, the calculation parameter corresponding to the approximate calculation may be specifically included; the calculation parameter may include the data identifier of the data set participating in the approximate calculation.

When the above-mentioned calculation initiator initiates the above-mentioned smart contract invocation transaction, if the calculation initiator directly connects with the blockchain node, it can package a smart contract transaction, and directly submit it to the connected blockchain node device point-to-point. Can. If the computing initiator accesses the blockchain through a blockchain linking service provided by a platform such as Baas (Blockchain as a Service), it can generate a call request for the above smart contract and submit the call request to the Baas platform , and then the Baas platform packages a smart contract call transaction based on the call parameters carried in the call request, and submits it to the blockchain node device.

The blockchain node device can receive the above-mentioned smart contract invocation transaction initiated by the above-mentioned calculation initiator, and when receiving the above-mentioned smart contract invocation transaction, it can respond to the smart contract invocation transaction, and call the above-mentioned smart contract on the blockchain. Data sets are approximated.

Step 104, in response to the smart contract invocation transaction, invoke the sampling logic included in the smart contract invocation transaction, and divide the data set corresponding to the data identifier into outlier data subsections consisting of several outlier data samples. set, and a non-outlier data subset composed of several non-outlier data samples, and sample the non-outlier data samples in the non-outlier data subset;

After receiving the above-mentioned smart contract invocation transaction initiated by the above-mentioned calculation initiator, the blockchain node device can respond to the smart contract invocation transaction, invoke the sampling logic contained in the smart contract, and analyze the data set corresponding to the data identifier. The data samples in are sampled.

Among them, it should be noted that after receiving the above-mentioned smart contract invocation transaction initiated by the above-mentioned calculation initiator, the blockchain node device usually needs a consensus algorithm supported by the blockchain, together with other blockchain nodes participating in the consensus. , perform consensus processing on the smart contract invocation transaction and the execution result of the smart contract invocation transaction. Since this specification does not involve improving the consensus process of the blockchain, the process of consensus processing of the smart contract invocation transaction and the execution result of the smart contract invocation transaction will not be described in detail in this specification.

In the illustrated embodiment, before calling the sampling logic included in the smart contract to sample the data samples in the data set corresponding to the data identifier, the blockchain node device may first obtain the above The smart contract invokes the above-mentioned data identification contained in the transaction, and reads the data set participating in the approximate calculation based on the data identification.

Wherein, when the data set participating in the approximate calculation is read based on the data identifier, it can be read from the blockchain or from outside the chain, which is not particularly limited in this specification.

In an implementation manner, the data set may specifically be pre-stored on the above-mentioned blockchain.

For example, a certificate storage contract for data storage can also be deployed on the blockchain. Before calling the above smart contract for calculation, the calculation initiator can package a certificate storage transaction to participate in the calculation. The data set is published to the deposit contract for deposit.

For another example, the execution logic corresponding to the contract code contained in the above smart contract may include, in addition to the above approximate calculation logic and the above sampling logic, data proof logic. That is, in addition to being used for approximate calculations, the smart contract itself also has its own function of depositing data. At this time, before calling the smart contract for calculation, the calculation initiator can also pre-publish the data set that needs to participate in the calculation to the smart contract by packaging a certificate deposit transaction. Read the above-mentioned data set that has been certified from its own contract storage space for approximate calculation.

In this case, the blockchain node device can obtain the data set corresponding to the data identification stored in the blockchain based on the above-mentioned data identification. For example, in this case, the data identifier may specifically be the certificate hash returned by the blockchain node after the above-mentioned data set is successfully stored on the blockchain.

In another implementation manner, the data set may also be specifically pre-stored in an off-chain database connected to the above-mentioned blockchain. In this case, the smart contract can obtain the data set corresponding to the data identifier from the above-mentioned off-chain database through its corresponding oracle machine program.

Among them, the above-mentioned oracle program may be a centralized oracle program, or a decentralized oracle program. When the above-mentioned oracle program is a centralized oracle program, the oracle program can be an oracle service program deployed on a service device outside the chain. When the above-mentioned oracle program is a decentralized oracle program, the oracle program can be an oracle contract deployed on the blockchain that connects with the above-mentioned smart contract. It should be noted that since this specification does not involve improvements related to the oracle program, in this specification, the above-mentioned smart contract obtains the data set corresponding to the data identifier from the above-mentioned off-chain database through the corresponding oracle program. The specific implementation process will not be described in detail in this specification.

For the calculation parameters included in the above-mentioned smart contract invocation transaction, in addition to the data identifiers of the above-mentioned data sets mentioned above, in practical applications, other forms of parameters related to approximate calculation may also be included.

In the illustrated embodiment, the above-mentioned calculation parameters may specifically include various parameters shown in the following table:

Parameter Type Parameter meaning Dataset ID Represents a collection of data involved in approximate computations Calculation Type ID Indicates the type of calculation that needs to be approximated difference Indicates the calculation error of the tolerable approximation calculation confidence probability Indicates the desired accuracy of the approximate calculation Sampling algorithm ID Indicates the specified sampling algorithm type

Among them, it should be noted that, except for the dataset ID, other parameters in the above table are optional parameters.

For example, if the calculation parameters in the above smart contract invocation transaction do not contain the calculation type ID, it means that the above smart contract is allowed to use the default calculation type to perform approximate calculation on the above data set. If the calculation parameters in the above smart contract invocation transaction do not contain an error value, it means that the tolerable calculation error is 0. If the calculation parameters in the above smart contract invocation transaction do not include confidence probability, it means that the confidence probability is 100%, and the expected approximate calculation accuracy is 100%. Exact calculation, no more approximate calculation.

In the illustrated embodiment, when the blockchain node device calls the sampling logic contained in the smart contract to sample the acquired data set corresponding to the above data identifier, in order to avoid outlier data in the above data set It will affect the final approximate calculation result. Specifically, the above data set can be divided into an outlier data subset composed of several outlier data samples, and a non-outlier data subset composed of several non-outlier data samples, and then only Sampling for data samples in a subset of non-outlier data.

The outlier data in the above data set can be calculated by the above smart contract.

In the illustrated embodiment, the sampling logic included in the smart contract may further include logic for performing outlier calculation on the data set. In this case, when the blockchain node device calls the sampling logic contained in the above smart contract to sample the acquired data set corresponding to the above data identifier, it can specifically execute the above logic for performing outlier calculation. For the above data Perform outlier data calculation on the data samples in the set, determine the outlier data samples and non-outlier data samples contained in the data set, and then create outlier data subsets based on the determined outlier data samples, and then create an outlier data subset according to the determined outlier data samples. of non-outlier data samples to create non-outlier data subsets.

Among them, the process of calculating outlier data for the data samples in the above data set usually refers to the process of counting data samples in the above data set that are significantly different from other data samples based on a certain statistical algorithm. Specifically, The method of statistical calculation of is not particularly limited in this specification. For example, in one example, the median of the values corresponding to the data samples in the above data set can be calculated, and then based on the median, the data samples in the data set whose values deviate significantly from the median can be filtered out, as Outlier data samples.

Of course, in practical applications, the outlier data in the above data set can also be manually calibrated in advance. In this case, the above-mentioned sampling logic included in the above-mentioned smart contract may also specifically include logic for screening outlier data for the above-mentioned data set. When the blockchain node device invokes the sampling logic contained in the above smart contract to sample the acquired data set corresponding to the above data identifier, it can specifically execute the above logic for screening outlier data, for the data in the above data set. The samples are screened for outlier data, and the outlier data samples and non-outlier data samples contained in the data set are determined, and then an outlier data subset is created according to the determined outlier data samples. Data samples create non-outlier subsets of data.

In the illustrated embodiment, before sampling the data samples in the non-outlier data subset, the number of samples to be sampled for the data samples in the non-outlier data subset may be calculated first, and then Then, the data samples in the non-outlier data subset are sampled according to the calculated sampling number.

In one embodiment shown, Hoeffding's Inequality is generally used to describe a random variable and an upper bound on the probability of deviation from its expected value. In the case of approximate calculation, the above-mentioned sampling number can be used as a random variable, the error value of the above-mentioned approximate calculation can be used as the expected value deviation, and the confidence probability of the above-mentioned approximate calculation can be used as the above-mentioned upper limit of probability. Therefore, the mathematical relationship between the above-mentioned sampling number, the above-mentioned approximately calculated error value, and the above-mentioned approximately calculated confidence probability can be described in this specification by using Hoovding's inequality. In other words, in the case of approximate calculation, the mathematical relationship between the above sampling number, the error value of the above approximate calculation, and the confidence probability of the above approximate calculation can be derived by using Hooding's inequality.

Wherein, when the mathematical relationship between the above-mentioned sampling number, the error value of the above-mentioned approximate calculation and the confidence probability of the above-mentioned approximate calculation is described by the Hooding's inequality, the Hooding's inequality is expressed as the following formula:

In the above formula, H represents the mathematical identifier of Hofding's inequality. n _g represents the number of samples. b _g and a _g respectively represent the maximum value and the minimum value of the data samples in the data set. δ represents the confidence probability; ε _g represents the error value corresponding to the above approximate calculation; N _g represents the total number of data samples in the data set.

The mathematical relationship between the above-mentioned sampling number, the above-mentioned approximate calculation error value and the above-mentioned approximate calculation confidence probability derived based on the above formula can be expressed by the following formula:

In the above smart contract, the above mathematical relationship can be maintained in advance. When the blockchain node device invokes the above smart contract to calculate the number of samples required for sampling the data samples in the above non-outlier data subset, it can obtain the confidence corresponding to the approximate calculation in the calculation parameters in the above smart contract invocation transaction probability δ, and the error value ε _g corresponding to the approximate calculation, and then input the obtained confidence probability δ and error value ε _g into the above-mentioned mathematical relationship maintained for calculation, and obtain the sampling number corresponding to the above non-outlier data subset .

Among them, it should be noted that the sampling method used for sampling the data samples in the non-outlier data subset is not particularly limited in this specification; for example, random sampling (Random Sampling), stratified sampling ( Stratified Sampling), etc.

In the following embodiments, random sampling and stratified sampling are used as examples to describe in detail the sampling process for the non-outlier data samples in the non-outlier data subset.

In the illustrated embodiment, if random sampling is used to randomly sample the data samples in the non-outlier data subset, in this case, the blockchain node device is calling the above smart contract, based on the calculated When random sampling is performed on the above data set, the random number used for random sampling can be obtained first, and then the non-outlier data samples in the non-outlier data subset are randomly sampled based on the obtained random number. , to obtain the data samples corresponding to the above-mentioned calculated sampling numbers.

The above random number is specifically used to control the randomness of the non-outlier data samples sampled from the above-mentioned non-outlier data subset. Non-outlier data samples sampled in the subset. For example, in one example, a random number can be used to represent the sample identifier of the non-outlier data sample to be sampled, and in the process of random sampling, the random number can be randomly selected from the non-outlier data subset. The value of the random number is used as a non-outlier data sample identified by the sample to complete data sampling.

It should be noted that the specific acquisition method of the above random number can be generated on the blockchain or acquired from outside the chain, which is not particularly limited in this specification.

The following are several specific methods for obtaining random numbers shown in this specification:

In the illustrated manner, a random function for generating random numbers may be pre-deployed on the blockchain. For example, in practical applications, the above random function can be specifically deployed on the blockchain as an independent smart contract, or deployed in the smart contract as the execution logic contained in the above smart contract for approximate calculation. In this case, a random tree can be generated on the blockchain by calling the above random function;

In another manner shown, a Trusted Execution Environment (Trusted Execution Environment) may be mounted on the above-mentioned blockchain node device. In the trusted execution environment, a random number seed for generating random numbers can be maintained in advance. In this case, a random number may be generated based on the random seed in the trusted execution environment.

In the third method shown, the target data parameters that can be used as random number seeds can also be obtained from the data parameters related to the data maintained by the above smart contract for approximate calculation, and then the target data parameters can be obtained based on the obtained target data parameters. The data parameter generates random numbers in the above smart contract. For example, the unique parameters such as the hash value of the historical block and the generation time stamp of the historical block maintained by the smart contract can also be used as the random number seed, and the random number can be calculated in the smart contract.

In the illustrated fourth manner, the above random number may be generated off-chain. In this case, the above-mentioned smart contract can also obtain the random number generated outside the chain through the oracle program corresponding to the smart contract.

In the illustrated fifth manner, a random number seed for further generating the above random number may be generated outside the chain. In this case, the above smart contract can also obtain the random number seed generated outside the chain through the oracle program corresponding to the smart contract, and then generate the random number seed in the smart contract based on the obtained random number seed random number.

In the sixth manner shown, the random number seed generated outside the chain can also be specifically carried in the smart contract invocation transaction as a calculation parameter. In this case, a random number seed generated off-chain included in the smart contract calling transaction can be obtained, and then a random number can be generated in the smart contract based on the obtained random number seed.

Several common implementations for obtaining random numbers are listed above. It should be emphasized that, in practical applications, it is obvious that methods other than the above-listed implementations can also be used to obtain random numbers. an enumeration.

In the illustrated embodiment, if random sampling is performed on the data samples in the non-outlier data subset by means of stratified sampling, in this case, when stratified sampling is used, it is usually necessary to The group data subset is divided into several buckets, and then data sampling is performed from these buckets respectively. Therefore, when the blockchain node device invokes the above smart contract to calculate the sampling quantity required for stratified sampling, it can obtain the confidence probability δ corresponding to the approximate calculation contained in the calculation parameters carried by the above smart contract invocation transaction, and the corresponding confidence probability δ for each The error value ε _k corresponding to the bucket, and then the obtained confidence probability δ and the error value ε _k of each bucket are input and maintained in the above mathematical relationship to be calculated respectively, and the corresponding buckets corresponding to the above non-outlier data subsets are obtained. the number of samples.

It should be noted that when performing hierarchical sampling on the above non-outlier data subsets, the number K of buckets to be divided, and the error value ε _k corresponding to each bucket can be specified by the calculation initiator and used as The calculation parameters are carried in the above smart contract invocation transaction. For example, in this case, the above calculation parameters need to carry K error values ε _k corresponding to each bucket in addition to a total error ε _g specified by the calculation initiator for approximate calculation of the above data set.

In addition, when performing hierarchical sampling on the above non-outlier data subsets, the number K of buckets that need to be divided, and the error value ε _k corresponding to each bucket, can also be calculated by the above smart contract in the chain. The optimal value obtained by autonomous calculation.

In the illustrated embodiment, the number K of buckets to be divided, and the error value ε _k corresponding to each bucket may be the optimal value obtained by the above-mentioned smart contract using the optimal solution method.

In this case, when the blockchain node device calls the sampling logic contained in the above smart contract to perform hierarchical sampling on the non-outlier data samples in the non-outlier data subset, it can first use the optimization solution method to solve the problem in The optimal number K of buckets that need to be divided into stratified sampling for the above non-outlier data subsets, and the optimal error value ε _k corresponding to each bucket, and then add the calculation parameters in the smart contract call transaction to the above The confidence probability δ corresponding to the approximate calculation, and the optimal error value ε _k corresponding to each bucket solved, are respectively calculated in the above-mentioned mathematical relationship maintained by the input, and the corresponding buckets corresponding to the above-mentioned non-outlier data subsets are obtained. the optimal number of samples. Then, stratified sampling may be performed on the data samples in the non-outlier data subset based on the calculated optimal number K and the optimal sampling number.

It should be noted that the specific type of the optimization solution method adopted by the above-mentioned smart contracts is not particularly limited in this specification. In practical applications, those skilled in the art can flexibly adopt different optimal solutions based on actual needs. Optimize the solution algorithm. For example, in practical applications, a commonly used optimal solution algorithm such as a gradient descent method (Gradient Descent) can be specifically adopted.

Among them, for the optimization solution method, it is usually necessary to set a clear constraint. In practical applications, the above constraints can usually be set based on specific solution objectives.

In the scenario of performing stratified sampling on the above non-outlier data subset, the optimization objective may include finding the optimal number of divided buckets, finding the optimal error value corresponding to each bucket, and so on. Then, in practical applications, the above-mentioned constraints can be set for the above-mentioned optimization solution method based on the above-mentioned optimization objective.

In the illustrated embodiment, based on the above-mentioned solution objective, setting constraints for the above-mentioned optimization solution method may specifically be:

The weighted average calculation is performed on the error values corresponding to each bucket, and the obtained weighted average error value is the smallest, and is not greater than the total error value corresponding to the approximate calculation for the above non-outlier data subset.

For example, the above constraints can be expressed as the following formula:

In the above formula, ε _g represents the total error value corresponding to the approximate calculation for the above non-outlier data subset. N _k represents the number of samples sampled from the k-th bucket. N represents the total number of samples sampled from the aforementioned subset of non-outlier data.

The following describes a specific algorithm flow for solving the optimal number of buckets required for stratified sampling and the optimal error value of each bucket by using the above constraints by using the accompanying drawings and specific embodiments.

Please refer to Fig. 2, Fig. 2 is a flow chart of an optimization solution method shown in this specification, including the following execution steps:

Step 201, initialize the i value; wherein, the i value represents the number of samples included in each bucket set by initialization. In addition to step 201, the following steps are iteratively executed:

Step 202, adjusting the value corresponding to the initialized i value;

The adjustment range of the i value can be set flexibly, and is not particularly limited in this specification.

Step 203, dividing the non-outlier data subset into several buckets containing i samples respectively;

In step 204, the above-mentioned confidence probability δ (that is, the confidence probability δ contained in the calculation parameters carried by the smart contract invocation transaction) and the adjusted i value (that is, the number of samples corresponding to each bucket) are used as calculation parameters, and are input into the mathematical The calculation is performed in the relationship to obtain the error values corresponding to each bucket, and the weighted average calculation is performed on the error values corresponding to each bucket to obtain the weighted average error value;

It should be noted that, if it is the first round of iteration, after step 204 is performed, steps 202 to 204 will be performed again, and the second round of iteration will be performed.

Step 205: Determine whether the weighted average error value is not greater than the total error value (that is, the error value corresponding to the approximate calculation contained in the calculation parameters carried by the smart contract invocation transaction), and is smaller than the weighted value calculated by the previous iteration. Average error value (that is, the weighted average error value calculated based on the i value before this round of iterative adjustment); if not, re-execute the above steps 202 to 205, continue to perform the next round of iteration, and repeat the above iterative process, The iteration is stopped until the optimization algorithm converges and the weighted average error value satisfying the above constraints is calculated.

Step 206, after stopping the iteration, obtain the optimal i value when the calculated weighted average error value satisfies the above constraints;

Step 207: Determine the optimal number of buckets to be divided when stratified sampling is performed for the non-outlier data subset based on the optimal i value, and again compare the above confidence probability with the above optimal i value. , input into the mathematical relationship for calculation, and obtain the optimal error value corresponding to each bucket. It should be noted that, in the above embodiment, it is a specific implementation of setting constraints for the above-mentioned optimization solution method based on the above-described solution objective. The above optimization solving methods set other forms of constraints. In this specification, after the above smart contract uses the optimal solution method to solve the optimal number of buckets to be divided, and the optimal sampling number corresponding to each bucket, the optimal number and the optimal error value can be paired based on the optimal number The subset of non-outlier data described above was stratified sampling.

In the illustrated embodiment, when the above-mentioned smart contract performs stratified sampling on the above-mentioned non-outlier data subset based on the optimal quantity and the optimal error value, firstly, the above-mentioned non-outlier data subset can be sampled according to the optimal quantity. The cluster data subset is divided into several buckets; for example, if the above optimal number is K, the above non-outlier data subset can be divided into K buckets. Then, the data samples in each bucket may be sampled according to the above optimal sampling quantity from each of the divided buckets.

Wherein, the specific sampling manner used for sampling the data samples in each bucket according to the above-mentioned optimal sampling quantity is not particularly limited in this specification.

For example, if the random sampling method is adopted, when the data samples in each bucket are sampled according to the above optimal sampling quantity, the random number used for random sampling can be obtained first, and then based on the obtained random number pair The non-outlier data samples in each bucket are randomly sampled to obtain non-outlier data samples corresponding to the calculated optimal sampling number. For the specific acquisition method of the above random number, reference may be made to the description of the previous embodiment, and details are not repeated here.

Step 106, further invoking the calculation logic included in the smart contract invocation transaction to perform accurate calculation for the outlier data samples in the outlier data subset, and for the non-outlier data sampled from the non-outlier data subset. An approximate calculation is performed on the sample, and the results of the exact calculation and the approximate calculation are combined as an approximate calculation result for the data set.

In this specification, after the data sampling for the non-outlier data subsets in the above-mentioned non-outlier data subsets is completed, an approximate calculation may be further performed for the sampled non-outlier data samples.

Among them, when the approximate calculation is performed for the sampled non-outlier data samples, the calculation type specified by the calculation initiator can be used for the approximate calculation, or the default calculation type supported by the above smart contract can be used for the approximate calculation. Make special restrictions.

For example, in the illustrated embodiment, the above-mentioned smart contract invocation transaction may further include a sampling algorithm ID. The sampling algorithm ID may be specifically used to indicate the calculation type designated by the calculation initiator to perform approximate calculation on the above-mentioned data set.

In this case, when performing approximate calculation on the sampled non-outlier data samples, the sampling algorithm ID included in the smart contract invocation transaction can be obtained, and then according to the calculation type indicated by the sampling algorithm ID, the collected non-outlier data samples can be obtained. Outlier data samples are approximated.

Of course, if the above-mentioned smart contract invocation transaction does not include the above-mentioned sampling algorithm ID, that is, the calculation initiator does not specify the calculation type to perform approximate calculation on the above-mentioned data set, it can also be based on the default calculation type supported by the above-mentioned smart contract. Approximate calculations are performed on non-outlier sample data.

For the above-mentioned outlier data subset, the outlier data samples in the above-mentioned outlier data subset may not be sampled. At the same time, since the approximate calculation results for the outlier data samples usually offset the approximate calculation results for the above-mentioned data sets, the outlier data samples in the above-mentioned outlier data subsets may not be approximated. Instead, make precise calculations.

Among them, when accurate calculation is performed for the outlier data samples in the outlier data subset, the calculation type specified by the calculation initiator can be used for accurate calculation, or the default calculation type supported by the above smart contract can be used for accurate calculation. is not particularly limited.

For example, when performing approximate calculation on the outlier data in the outlier data subset, the sampling algorithm ID included in the smart contract invocation transaction can be obtained, and then according to the calculation type indicated by the sampling algorithm ID, the outlier data in the outlier data subset is calculated. Cluster data samples for exact calculations. Of course, if the above-mentioned smart contract invocation transaction does not include the above-mentioned sampling algorithm ID, it is also possible to accurately calculate the outlier data in the outlier data subset based on the default calculation type supported by the above-mentioned smart contract.

It should be noted that the calculation types corresponding to the above approximate calculation and exact calculation are not particularly limited in this specification. For example, summation, averaging, etc. may be included, which will not be enumerated in this specification.

After the accurate calculation for the outlier data samples in the outlier data subset and the approximate calculation for the non-outlier data samples sampled from the non-outlier data subset are completed, the results of the above accurate calculation and the above approximate calculation can be combined, as the final approximate calculation result for the above data set.

In the illustrated embodiment, the above-mentioned smart contract for performing approximate calculation may specifically be a privacy smart contract deployed in a trusted execution environment carried by a blockchain node device.

In this scenario, the calculation parameters in the above-mentioned smart contract invocation transaction and the obtained data samples in the above-mentioned data set are usually encrypted in advance. Before the blockchain node device calls the sampling logic contained in the above smart contract to divide the data set into outlier data subsets and non-outlier data subsets, it can also perform calculations on the above calculation parameters and Decrypt the obtained data samples in the above-mentioned data set respectively.

For example, in one example, a pair of asymmetric key pairs for encrypting and decrypting data may be allocated to the above-mentioned trusted execution environment, and the private key of the above-mentioned asymmetric key may be stored in the above-mentioned trusted execution environment, The public key of the above-mentioned asymmetric key is released to the above-mentioned calculation initiator. The calculation parameters in the above-mentioned smart contract invocation transaction and the obtained data samples in the above-mentioned data set can be encrypted in advance based on the above-mentioned public key. Before calling the sampling logic contained in the above smart contract and randomly sampling the data set corresponding to the above data identifier, the blockchain node device can also use the maintained private key to calculate the above calculation parameters in the trusted execution environment. and decrypting the obtained data samples in the above data set respectively. In the above technical solution, in the scenario of invoking a smart contract to perform approximate calculation on a data set, by introducing a sampling mechanism for the data set into the smart contract, the accuracy of the approximate calculation result can be reduced without sacrificing the accuracy of the approximate calculation result. The time-consuming when the approximate calculation is performed on the data set improves the calculation efficiency when the approximate calculation is performed on the data set.

For example, still taking business-related data sets pre-existing on the blockchain as an example, after the data sampling mechanism is introduced into smart contracts, the total time spent by smart contracts to calculate business-related data sets , which can usually be expressed by the following formula:

Wherein, in the above formula, _ng represents the number of data samples sampled from the data set. N _g represents the total number of data samples in the data set. Since the value of n _g is usually an order of magnitude difference compared to the value of N _g , after the sampling mechanism is introduced into the smart contract, the time-consuming calculation of the data set through the smart contract will also be reduced by orders of magnitude. It can be seen that the introduction of the sampling mechanism into the smart contract can significantly shorten the time-consuming calculation of the data set and improve the computational efficiency of approximate calculation of the data set.

Moreover, in the process of performing the approximate calculation on the data set, the approximate calculation is not performed after sampling the outlier data in the data set, but the accurate calculation is performed directly without sampling, so that the outlier data can be included in the data set. In the case of data, it is further avoided that these outlier data samples affect the accuracy of the approximate calculation result for the data set, and the accuracy of the approximate calculation for the data set can be ensured to the greatest extent.

Corresponding to the above method embodiments, the present application also provides device embodiments.

Embodiments of the apparatus of this specification can be applied to electronic equipment. The apparatus embodiment may be implemented by software, or may be implemented by hardware or a combination of software and hardware. Taking software implementation as an example, a device in a logical sense is formed by reading the corresponding computer program instructions in the non-volatile memory into the memory for operation by the processor of the electronic device where the device is located.

From the perspective of hardware, as shown in FIG. 3 , which is a hardware structure diagram of the electronic device where the device of this specification is located, except for the processor, memory, network interface, and non-volatile memory shown in FIG. 3 , In the embodiment, the electronic device where the apparatus is located generally may also include other hardware according to the actual function of the electronic device, and details are not described herein again.

FIG. 4 is a block diagram of a smart contract-based computing device shown in an exemplary embodiment of the present specification.

Referring to FIG. 4 , the smart contract-based computing device 40 can be applied to the electronic equipment shown in the aforementioned FIG. 3 , and a smart contract for performing approximate calculations is deployed on the blockchain, and the device 40 includes:

A receiving module 401, receiving a smart contract invocation transaction for the smart contract initiated by a computing initiator; wherein, the smart contract invocation transaction includes a calculation parameter corresponding to the approximate calculation; the calculation parameter includes data participating in the approximate calculation The data identifier of the collection;

Sampling module 402, in response to the smart contract invocation transaction, invokes the sampling logic included in the smart contract invocation transaction, and divides the data set corresponding to the data identifier into outlier data consisting of several outlier data samples a subset, and a non-outlier data subset composed of several non-outlier data samples, and sampling is performed for the non-outlier data samples in the non-outlier data subset;

The calculation module 403 further invokes the calculation logic included in the smart contract invocation transaction to perform accurate calculation for the outlier data samples in the outlier data subset, and for the non-outlier data samples sampled from the non-outlier data subset An approximate calculation is performed on a sample of data, and the results of the exact calculation and the approximate calculation are combined as an approximate calculation result for the data set.

In this embodiment, the device 40 further includes:

The acquisition module 404 (not shown in FIG. 4 ), in the sampling module 402, the data set corresponding to the data identifier is divided into outlier data subsets composed of several outlier data samples, and outlier data subsets composed of several non-outlier data samples. Before the non-outlier data subset composed of data samples, obtain the data set corresponding to the data identifier stored on the blockchain; or, through the oracle program corresponding to the smart contract, from the data set corresponding to the The data set corresponding to the data identifier is obtained from the off-chain database connected by the blockchain.

In this embodiment, the sampling module 402:

Perform outlier data calculation on the data samples in the data set corresponding to the data identifier to determine the outlier data samples and non-outlier data samples included in the data set;

The outlier data subset is created based on the outlier data samples, and a non-outlier data subset is created based on the non-outlier data samples.

In this embodiment, the calculation parameter includes a confidence probability corresponding to the approximate calculation; and a total error value corresponding to the approximate calculation; the confidence probability represents the accuracy of the approximate calculation; the intelligence The contract maintains the confidence probability corresponding to the approximate calculation, the error value corresponding to the approximate calculation, and the sampling number corresponding to the data set participating in the approximate calculation, which is derived based on the Houghding inequality. the mathematical relationship between them;

The sampling module 402 further:

Before sampling the data samples in the non-outlier data subset, the confidence probability corresponding to the approximate calculation and the error value corresponding to the approximate calculation are input into the mathematical relationship to perform Calculate to obtain the number of samples corresponding to the non-outlier data subset.

In this embodiment, the data relationship is represented by the following formula:

Wherein, in the above formula, n _g represents the number of samples; b _g and a _g represent the maximum and minimum values of the data samples in the data set, respectively; δ represents the confidence probability; ε _g represents the error value; N _g represents the total number of data samples in the data set.

In this embodiment, the sampling module 402:

The non-outlier data samples in the non-outlier data subset are sampled according to the calculated sampling number.

In this embodiment, the sampling performed for the non-outlier data samples in the non-outlier data subset includes random sampling;

The sampling module 402 further:

Get a random number for random sampling;

Random sampling is performed on the non-outlier data samples in the non-outlier data subset based on the random number to obtain non-outlier data samples corresponding to the calculated sampling number.

In this embodiment, the sampling performed for the non-outlier data samples in the non-outlier data subset includes stratified sampling;

The sampling module 402 further:

An optimal solution method is used to obtain the optimal number of data subsets that need to be divided when stratified sampling is performed on the non-outlier data subsets, and the optimal error value corresponding to each divided data subset. ;

Input the confidence probability corresponding to the approximate calculation and the optimal error value corresponding to the respective data subsets into the mathematical relationship for calculation, and obtain the corresponding values for the respective data subsets. Optimal sampling number;

The data set is divided into several data subsets according to the optimal number, and non-outlier data samples in each data subset are sampled respectively according to the optimal sampling data.

In this embodiment, the constraints adopted by the optimization solution method include: the weighted average error value obtained by performing the weighted average calculation on the error values corresponding to each data subset is the smallest and not greater than the total error value ;

The sampling module 402 further performs the following steps:

Step A, adjust the value corresponding to the initialized i value;

Step B, dividing the non-outlier data subset into several data subsets containing i samples respectively;

In step C, the confidence probability and the adjusted i value are used as calculation parameters, and are input into the mathematical relationship for calculation, so as to obtain the error values corresponding to the respective data subsets, and for the respective data subsets. The corresponding error value is calculated by weighted average to obtain the weighted average error value;

Step D, determine whether the weighted average error value is not greater than the total error value, and is smaller than the weighted average error value calculated based on the i value before this adjustment; if not, re-execute the above step A - Step D, stop the iteration until the calculated weighted average error value satisfies the constraint condition, and obtain the optimal i value when the weighted average error value satisfies the constraint condition;

Step E: Determine the optimal number of data subsets to be divided when performing stratified sampling for the non-outlier data subset based on the optimal i value, and compare the confidence probability with the optimal number of data subsets. The i value is input into the mathematical relationship for calculation to obtain the optimal error values corresponding to the respective data subsets.

In this embodiment, the sampling module further:

Get a random number for random sampling;

The non-outlier data samples in each data subset are randomly sampled based on the random numbers, to obtain non-outlier data samples corresponding to the calculated optimal sampling number.

In this embodiment, the sampling module further performs any one of the following:

calling the random function deployed on the blockchain to generate a random tree for random sampling;

generating a random number in the trusted execution environment based on the random number seed maintained in the trusted execution environment carried in the node device;

Obtain a target data parameter as the random number seed from the data parameters related to the data maintained by the smart contract, and generate a random number for random sampling in the smart contract based on the obtained target data parameter;

Obtain random numbers generated outside the chain for random sampling through the oracle program corresponding to the smart contract;

Through the oracle program corresponding to the smart contract, a random number seed generated outside the chain for generating random numbers is obtained, and based on the obtained target data parameters, a random number for random sampling is generated in the smart contract. obtain the random number seed generated outside the chain included in the calculation parameter, and generate a random number for random sampling in the smart contract based on the random number seed.

In this embodiment, the calculation parameter further includes an algorithm identifier;

The computing module 403:

According to the calculation type indicated by the algorithm identifier, accurately calculate the outlier data samples in the outlier data subset;

Approximate calculations are performed on the non-outlier data samples sampled from the non-outlier data subset, including:

According to the calculation type indicated by the algorithm identifier, an approximate calculation is performed on the non-outlier data samples sampled from the non-outlier data subset.

In this embodiment, the smart contract is deployed in a trusted execution environment carried by the node device; the calculation parameters and the data samples in the data set are encrypted in advance;

The sampling module 402 further:

Before dividing the data set corresponding to the data identifier into an outlier data subset composed of a number of outlier data samples, and a non-outlier data subset composed of a number of non-outlier data samples, before the possible The computing parameters and the acquired data samples in the data set are respectively decrypted in the information execution environment.

The systems, devices, modules or units described in the above embodiments may be specifically implemented by computer chips or entities, or by products with certain functions. A typical implementation device is a computer, which may be in the form of a personal computer, laptop computer, cellular phone, camera phone, smart phone, personal digital assistant, media player, navigation device, email sending and receiving device, game control desktop, tablet, wearable device, or a combination of any of these devices.

In a typical configuration, a computer includes one or more processors (CPUs), input/output interfaces, network interfaces, and memory.

Memory may include non-persistent memory in computer readable media, random access memory (RAM) and/or non-volatile memory in the form of, for example, read only memory (ROM) or flash memory (flash RAM). Memory is an example of a computer-readable medium.

Computer-readable media includes both persistent and non-permanent, removable and non-removable media, and storage of information may be implemented by any method or technology. Information may be computer readable instructions, data structures, modules of programs, or other data. Examples of computer storage media include, but are not limited to, phase-change memory (PRAM), static random access memory (SRAM), dynamic random access memory (DRAM), other types of random access memory (RAM), read only memory (ROM), Electrically Erasable Programmable Read Only Memory (EEPROM), Flash Memory or other memory technology, Compact Disc Read Only Memory (CD-ROM), Digital Versatile Disc (DVD) or other optical storage, Magnetic tape cartridges, disk storage, quantum memory, graphene-based storage media or other magnetic storage devices or any other non-transmission media can be used to store information that can be accessed by computing devices. As defined herein, computer-readable media does not include transitory computer-readable media, such as modulated data signals and carrier waves.

It should also be noted that the terms "comprising", "comprising" or any other variation thereof are intended to encompass a non-exclusive inclusion such that a process, method, article or device comprising a series of elements includes not only those elements, but also Other elements not expressly listed, or which are inherent to such a process, method, article of manufacture, or apparatus are also included. Without further limitation, an element qualified by the phrase "comprising a..." does not preclude the presence of additional identical elements in the process, method, article of manufacture, or device that includes the element.

The foregoing describes specific embodiments of the present specification. Other embodiments are within the scope of the appended claims. In some cases, the actions or steps recited in the claims can be performed in an order different from that in the embodiments and still achieve desirable results. Additionally, the processes depicted in the figures do not necessarily require the particular order shown, or sequential order, to achieve desirable results. In some embodiments, multitasking and parallel processing are also possible or may be advantageous.

The terminology used in one or more embodiments of this specification is for the purpose of describing a particular embodiment only and is not intended to limit the one or more embodiments of this specification. As used in the specification or embodiments and the appended claims, the singular forms "a," "the," and "the" are intended to include the plural forms as well, unless the context clearly dictates otherwise. It will also be understood that the term "and/or" as used herein refers to and includes any and all possible combinations of one or more of the associated listed items.

It will be understood that although the terms first, second, third, etc. may be used in this specification to describe various information, such information should not be limited by these terms. These terms are only used to distinguish the same type of information from each other. For example, the first information may also be referred to as the second information, and similarly, the second information may also be referred to as the first information without departing from the scope of one or more embodiments of the present specification. Depending on the context, the word "if" as used herein can be interpreted as "at the time of" or "when" or "in response to determining."

The above descriptions are only preferred embodiments of one or more embodiments of this specification, and are not intended to limit one or more embodiments of this specification. All within the spirit and principles of one or more embodiments of this specification, Any modifications, equivalent replacements, improvements, etc. made should be included within the protection scope of one or more embodiments of this specification.

Claims (16)

1. A computing method based on intelligent contracts, applied to node devices in a blockchain on which intelligent contracts for performing approximate computation are deployed, the method comprising:

receiving an intelligent contract invoking transaction aiming at the intelligent contract initiated by a calculation initiator; wherein the smart contract invocation transaction includes a calculation parameter corresponding to the approximate calculation; the calculation parameters comprise data identifications of data sets participating in approximate calculation;

responding to the intelligent contract call transaction, calling sampling logic contained in the intelligent contract call transaction, dividing the data set corresponding to the data identification into an outlier data subset formed by a plurality of outlier data samples and a non-outlier data subset formed by a plurality of non-outlier data samples, and sampling the non-outlier data samples in the non-outlier data subset;

further invoking the intelligent contract to invoke the computation logic included in the transaction, performing a precise computation on outlier data samples of the subset of outlier data, performing an approximate computation on non-outlier data samples sampled from the subset of non-outlier data, and merging results of the precise computation and the approximate computation as an approximate computation result for the set of data.

2. The method of claim 1, prior to dividing the set of data corresponding to the data identification into an outlier subset of outlier data samples and a non-outlier subset of non-outlier data samples, further comprising:

acquiring a data set corresponding to the data identification and stored on the block chain; or,

and acquiring a data set corresponding to the data identification from an off-chain database interfacing with the blockchain through a predictive machine program corresponding to the intelligent contract.

3. The method of claim 2, dividing the set of data corresponding to the data identification into an outlier subset of outlier data samples and a non-outlier subset of non-outlier data samples, comprising:

performing outlier data calculation on data samples in the data set corresponding to the data identification to determine outlier data samples and non-outlier data samples contained in the data set;

creating the outlier data subset based on the outlier data samples and creating a non-outlier data subset based on the non-outlier data samples.

4. The method of claim 3, the calculation parameter comprising a confidence probability corresponding to the approximation calculation; and, a total error value corresponding to the approximation calculation; the confidence probability characterizes an accuracy of the approximation calculation; the intelligent contract maintains a mathematical relationship which is derived based on the Hough's inequality and is used for describing a confidence probability corresponding to the approximate calculation, an error value corresponding to the approximate calculation and a sampling number corresponding to a data set participating in the approximate calculation;

prior to sampling the data samples in the non-outlier subset of data, further comprising:

inputting the confidence probability corresponding to the approximate calculation and the error value corresponding to the approximate calculation into the mathematical relationship for calculation to obtain the number of samples corresponding to the non-outlier data subset.

5. The method of claim 4, the data relationship being represented by the following formula:

wherein, in the above formula, n_gRepresenting the number of samples; b_g、a_gRespectively representing a maximum value and a minimum value of data samples in the data set; δ represents the confidence probability; epsilon_gRepresenting the error value; n is a radical of hydrogen_gRepresenting the total number of data samples in the data set.

6. The method of claim 3, sampling non-outlier data samples of the subset of non-outlier data, comprising:

sampling non-outlier data samples of the subset of non-outlier data according to the calculated number of samples.

7. The method of claim 6, the sampling for non-outlier data samples of the subset of non-outlier data comprising random sampling;

sampling non-outlier data samples of the subset of non-outlier data according to the calculated number of samples, comprising:

acquiring a random number for random sampling;

and randomly sampling non-outlier data samples in the non-outlier data subset based on the random number to obtain non-outlier data samples corresponding to the calculated sampling number.

8. The method of claim 6, the sampling for non-outlier data samples of the subset of non-outlier data comprising hierarchical sampling;

sampling non-outlier data samples of the subset of non-outlier data according to the calculated number of samples, comprising:

adopting an optimization solving method to solve the optimal number of the data subsets required to be divided when the non-outlier data subsets are subjected to hierarchical sampling and the optimal error value corresponding to each divided data subset;

inputting the confidence probability corresponding to the approximate calculation and the optimal error value corresponding to each data subset into the mathematical relationship for calculation to obtain optimal sampling numbers respectively corresponding to each data subset;

and dividing the data set into a plurality of data subsets according to the optimal quantity, and respectively sampling non-outlier data samples in each data subset according to the optimal sampling data.

9. The method of claim 8, wherein the constraints employed by the optimization solution method include: performing weighted average calculation on error values corresponding to the data subsets to obtain a weighted average error value which is the minimum and is not greater than the total error value;

adopting an optimization solving method to solve the optimal number of the data subsets required to be divided when the non-outlier data subsets are subjected to hierarchical sampling and the optimal error value corresponding to each divided data subset, wherein the optimization solving method comprises the following steps:

step A, adjusting a numerical value corresponding to the initialized value i;

step B, dividing the non-outlier data subsets into a plurality of data subsets respectively containing i sample numbers;

step C, inputting the confidence probability and the adjusted i value as calculation parameters into the mathematical relationship for calculation to obtain error values respectively corresponding to the data subsets, and performing weighted average calculation on the error values corresponding to the data subsets to obtain weighted average error values;

step D, determining whether the weighted average error value is not greater than the total error value and is less than the weighted average error value calculated based on the i value before the current adjustment; if not, re-executing the steps A-D until the calculated weighted average error value meets the constraint condition, stopping iteration, and obtaining an optimal i value when the weighted average error value meets the constraint condition;

and E, determining the optimal number of the data subsets which need to be divided when the non-outlier data subsets are subjected to hierarchical sampling based on the optimal i value, and inputting the confidence probability and the optimal i value into the mathematical relationship for calculation to obtain optimal error values respectively corresponding to the data subsets.

10. The method of claim 8, sampling non-outlier data samples in each data subset according to the optimal sampling data, respectively, comprising:

acquiring a random number for random sampling;

and respectively carrying out random sampling on the non-outlier data samples in each data subset based on the random numbers to obtain the non-outlier data samples corresponding to the calculated optimal sampling number.

11. The method of claim 7 or 10, the obtaining random numbers for random sampling comprising any one of:

calling a random function deployed on the block chain to generate a random tree for random sampling;

generating a random number in a trusted execution environment based on a random number seed maintained in the trusted execution environment loaded in the node device;

acquiring target data parameters serving as the random number seeds from data-related data parameters maintained by the intelligent contract, and generating random numbers for random sampling in the intelligent contract based on the acquired target data parameters;

acquiring random numbers which are generated outside a chain and used for random sampling through a language predicting machine program corresponding to the intelligent contract;

acquiring a random number seed which is generated outside a chain and used for generating a random number through a prediction machine program corresponding to the intelligent contract, and generating the random number used for random sampling in the intelligent contract based on the acquired target data parameter; and acquiring random number seeds which are included in the calculation parameters and generated outside the chain, and generating random numbers for random sampling in the intelligent contract based on the random number seeds.

12. The method of claim 1, the calculation parameters further comprising an algorithm identification;

performing a refined calculation on outlier data samples in the subset of outlier data, comprising:

accurately calculating the outlier data samples in the outlier data subset according to the calculation type indicated by the algorithm identifier;

performing an approximation calculation on non-outlier data samples sampled from the non-outlier data subset, comprising:

and performing approximate calculation on non-outlier data samples sampled from the non-outlier data subset according to the calculation type indicated by the algorithm identification.

13. The method of claim 1, the smart contract deployed in a trusted execution environment hosted by the node device; the calculation parameters and the data samples in the data set are encrypted in advance;

before the dividing the data set corresponding to the data identifier into an outlier data subset composed of a plurality of outlier data samples and a non-outlier data subset composed of a plurality of non-outlier data samples, the method further includes:

and respectively decrypting the calculation parameters and the data samples in the acquired data set in the trusted execution environment.

14. An intelligent contract-based computing apparatus applied to a node device in a blockchain on which an intelligent contract for performing approximate computation is deployed, the apparatus comprising:

the receiving module is used for receiving an intelligent contract calling transaction aiming at the intelligent contract and initiated by a calculation initiator; wherein the smart contract invocation transaction includes a calculation parameter corresponding to the approximate calculation; the calculation parameters comprise data identifications of data sets participating in approximate calculation;

the sampling module is used for responding to the intelligent contract call transaction, calling sampling logic contained in the intelligent contract call transaction, dividing the data set corresponding to the data identification into an outlier data subset formed by a plurality of outlier data samples and a non-outlier data subset formed by a plurality of non-outlier data samples, and sampling the non-outlier data samples in the non-outlier data subset;

and the calculation module is used for further calling the calculation logic included in the intelligent contract calling transaction, performing accurate calculation on the outlier data samples in the outlier data subset, performing approximate calculation on the non-outlier data samples obtained by sampling from the non-outlier data subset, and combining the results of the accurate calculation and the approximate calculation to obtain an approximate calculation result on the data set.

15. An electronic device, comprising:

a processor;

a memory for storing processor-executable instructions;

wherein the processor implements the steps of the method of any one of claims 1-13 by executing the executable instructions.

16. A computer readable storage medium having stored thereon computer instructions which, when executed by a processor, carry out the steps of the method according to any one of claims 1 to 13.

Images