Human Resource Information Sharing and Management in Business Administration Environment Combined with Blockchain Technology

The approximate flow of the consistency protocol of the algorithm is as follows: assuming that 3f + 1 node exists in the system (f is the number of Byzantine nodes tolerated by the system), in the preparation phase, the master node collects transaction information to pack the block and broadcasts it to the whole network. In the preparation phase, each node, upon receiving transaction information, simulates the execution of these transactions, calculates the Hash digest required for the new block and broadcasts the preparation information to the whole network [25].

Due to the consistency protocol every request executed by the system, the node has to record the log (including the messages sent in the request phase, pre-preparation phase, preparation phase, and acknowledgement phase). If the system does not clean up in time it will lead to a large amount of resources being occupied, affecting the availability of the system. As some nodes are unable to execute requests after starting from a certain sequence number due to network delay.

The checkpointing protocol of the PBFT algorithm is a good solution to the problems of wastage of system resources due to excessive logging, reduced availability and inconsistent node states due to Byzantine nodes.

Every node in the blockchain has to work under the same configuration information which is known as view. In PBFT algorithm after the failure of the master node, the master node needs to be replaced by running the view switching protocol. After the failure of the master node, the master node is elected according to equation (1): (1){ V=V+1 P=Vmod|N|$$\left\{ {\begin{array}{*{20}{l}} {V = V + 1} \\ {P = V\ \bmod \ |N|} \end{array}} \right.$$

The view switching protocol is triggered by two conditions: 1)

No pre-preparation message broadcast by the master node is received within fixed time T1;

And T2 > T1, when one of the above conditions is met, the system will automatically trigger the view switching protocol. The specific process is as follows:

First, view number +1, sends view-change message to all nodes.

Second, all nodes send view-change-ack acknowledgement messages to the master node in the new view when they receive 2f + 1 (f denotes the number of tolerable Byzantine nodes within the system) view-change messages. The corresponding new master node in the new view will collect view-change-ack messages from other nodes.

Finally, when 2f acknowledgement messages are collected, assemble and broadcast the new-view message to be sent to all nodes, after which the consistency protocol is executed based on the local link data.

Although the PBFT algorithm solves the Byzantine problem, there are still problems: firstly, the algorithm communication overhead is too large, and the time complexity of inter-node communication of the whole consensus process is O(N2)$$O\left( {{N^2}} \right)$$ (N is the total number of nodes in the network); secondly, the PBFT algorithm can not dynamically add or delete nodes, and it can only reboot the system when joining a new node, which is a large consumption of resources; and lastly, the trustworthiness of nodes themselves can not be guaranteed resulting in malicious nodes may act as the master node, causing security risks, constantly switching views, and reducing operational efficiency.

The C4.5 algorithm is an improvement of the ID3 algorithm, before studying the C4.5 algorithm we analyze the principle of the ID3 algorithm.

In ID3 algorithm, let the training dataset be X, and the learning objective is to categorize the training dataset into n classes, denoted as A={X1,X2,…,Xn}$$A = \left\{ {{X_1},{X_2}, \ldots ,{X_n}} \right\}$$. Let the number of training instances in class i be |Xi|=Ai$$\left| {{X_i}} \right| = {A_i}$$, and the total number of instances in X be |X|, then the probability that the training instances belong to class i is: (2)P(Ci)=Ai|X|$$P\left( {{C_i}} \right) = \frac{{{A_i}}}{{|X|}}$$

At this point the decision tree has an uncertainty of H(X, A) for A, abbreviated as H(X) or Info(X). (3)H(X,A)=−∑P(Ai)logP(Ai)$$H(X,A) = - \sum P \left( {{A_i}} \right)\log P\left( {{A_i}} \right)$$

The learning process of a decision tree is the process of gradually reducing the degree of uncertainty in the division of the decision tree. If attribute c is selected for testing, suppose c has attribute value c₁, c₂,…, c_n, and the number of instances belonging to class i in case c = c_j is A_ij, denote p(Ai;c=cj)=Aij|X|$$p\left( {{A_i};c = {c_j}} \right) = \frac{{{A_{ij}}}}{{\left| X \right|}}$$, then p(Ai;c=cj)$$p\left( {{A_i};c = {c_j}} \right)$$ is the probability that it belongs to class i when the value of test attribute c is c_j [26].

Let X_j be the set of instances of c = c, where the decision tree’s degree of uncertainty about the classification is actually the condition of the training dataset on c: (4)H(Xj)=−∑p(Ai/c=cj)log(Ai/c=cj)$$H\left( {{X_j}} \right) = - \sum p \left( {{A_i}/c = {c_j}} \right)\log \left( {{A_i}/c = {c_j}} \right)$$

Select test attribute c for each leaf node X extending from c, for the categorized information if it is: (5)H(X/c)=∑jp(c=cj)H(Xj)$$H(X/c) = \sum\limits_j p \left( {c = {c_j}} \right)H\left( {{X_j}} \right)$$ (6)H(X/c) = −∑i∑jp(Ai;c=cj)logp(Ai/c=cj) = −∑i∑jp(c=cj)p(Ai/c=cj)logp(Ai/c=cj) = −∑jp(c=cj)∑ip(Ai/c=cj)logp(Al/c=cj)$$\begin{array}{rcl} H(X/c) &=& - \sum\limits_i {\sum\limits_j p } \left( {{A_i};c = {c_j}} \right)\log p\left( {{A_i}/c = {c_j}} \right) \\ &=& - \sum\limits_i {\sum\limits_j p } \left( {c = {c_j}} \right)p\left( {{A_i}/c = {c_j}} \right)\log p\left( {{A_i}/c = {c_j}} \right) \\ &=& - \sum\limits_j p \left( {c = {c_j}} \right)\sum\limits_i p \left( {{A_i}/c = {c_j}} \right)\log p\left( {{A_l}/c = {c_j}} \right) \\ \end{array}$$

The information gain of attribute c is the amount of mutual information provided by the classification for: (7)I(X;c)=H(X)−H(X/c)$$I(X;c) = H(X) - H(X/c)$$

The larger the result calculated in Eq. The larger the information provided to the classification by the test attribute c, the smaller the uncertainty of the classification after selecting attribute c. The ID3 algorithm selects the attribute that makes the value of I(X; c) the largest as the test attribute.

The C4.5 algorithm inherits the advantages of the ID3 algorithm, while introducing new methods and adding new features. 1)

Gain Ratio

Unlike the ID3 algorithm, the C4.5 algorithm uses the gain ratio to select the row attributes, and the gain ratio is defined as follows: (8)GainRatio=Gain(X,c)SplitInfo(X,c)$$GainRatio = \frac{{Gain\left( {X,c} \right)}}{{SplitInfo\left( {X,c} \right)}}$$

The above equation shows that the smaller the value of SplitInfo(X,c)$$SplitInfo\left( {X,c} \right)$$ the better when different attributes provide the same gain Gain(X,c)$$Gain\left( {X,c} \right)$$, and the smaller the value of SplitInfo(X,c)$$SplitInfo\left( {X,c} \right)$$ the smaller the price to be paid to get the value taken about attribute c. Denominator SplitInfo(X,c)$$SplitInfo\left( {X,c} \right)$$ is the entropy value of c. If we have an attribute c and divide X into sets X₁, X₂,⋯, X_n and X₁ + X₂ + ⋯ + X_n = X according to its different values c = c₁, c₂,⋯, c_n, then: (9)SplitInfo(X,c)=−∑Xi/Xlog2Xi/X$$SplitInfo(X,c) = - \sum {{X_i}} /X{\log_2}{X_i}/X$$

2)

Processing of continuous-valued attributes

The ID3 algorithm is used to process discrete attribute values, but in practical applications, many attribute values are continuous, and the general process of the C4.5 algorithm for continuous attribute values is as follows: 1) Sort the dataset of attribute values; 2) Dynamically divide the dataset according to different thresholds; 3) Determine a threshold when the output is changed; 4) Take the mid-point of the two actual values as a threshold; 5) Two divisions are taken and all the samples are in these two divisions taken; 6) All the possible thresholds, gains, and gain ratios are derived; 7) Each attribute will turn out to have two values i.e., less than the threshold or greater than or equal to the threshold.

The pruning strategy used by the C4.5 algorithm in this experiment is pessimistic error pruning. The principle of this algorithm is analyzed in detail below.

If N(t) is the number of training set instances on node t and e(t) is the number of misclassified instances on the node, the misclassification rate is estimated as: (10)r(t)=e(t)N(t)$$r(t) = \frac{{e(t)}}{{N(t)}}$$

The continuity correction error rate is: (11)r′(t)=e(t)+1/2N(t)$$r^\prime (t) = \frac{{e(t) + 1/2}}{{N(t)}}$$

Accordingly, the misclassification rate of subtree T_t is: (12)r(Tt)=∑e(i)∑N(i)$$r\left( {{T_t}} \right) = \frac{{\sum e (i)}}{{\sum N (i)}}$$

where i takes the leaves of the traversed subtree. The misclassification rate after such correction is: (13)r′(Tt)=∑(e(i)+1/2∑N(i)=∑e(i)+NTt/2∑N(i)$$r^\prime \left( {{T_t}} \right) = \frac{{\sum {(e(} i) + 1/2}}{{\sum N (i)}} = \frac{{\sum e (i) + {N_{{T_t}}}/2}}{{\sum N (i)}}$$

where N_T is the number of leaves on the node.

Using the training data, the subtrees always produce smaller errors than the corresponding nodes, but this is not the case when using the corrected numbers, as they depend on the number of leaves, not just the number of errors. The algorithm only maintains subtrees whose corrected numbers are one standard deviation better than those of the nodes.

The standard deviation is calculated as follows: (14)SE[n′(Ti)]=n′(Tt)*(N(t)−n′(Ti))N(t)$$SE\left[ {n^\prime\left( {{T_i}} \right)} \right] = \sqrt {\frac{{n^\prime\left( {{T_t}} \right)^*\left( {N(t) - n^\prime\left( {{T_i}} \right)} \right)}}{{N(t)}}}$$

where for the nodes there are: (15)n′(t)=e(t)+1/2$$n'(t) = e(t) + 1/2$$

And for subtrees there are: (16)n′(Tt)=∑e(i)+NTt/2$$n'\left( {{T_t}} \right) = \sum e (i) + {N_{{T_t}}}/2$$

Therefore, if the number of misclassifications after subtree correction is greater than the number of misclassifications after node correction, this pruning method suggests pruning the subtree.

The advantage of this method is that the same training set is used for tree growth and tree pruning and it is very fast as it only needs to be scanned once and examine each node once.

In order to provide a consensus algorithm that has low operational communication overhead, can dynamically add and remove nodes, and has reliable node identities, this paper proposes a Byzantine fault-tolerant algorithm, DTBFT, based on C4.5 decision tree classification. The flowchart of the DTBFT algorithm is shown in Fig. 2:

Figure 2.

Algorithm flowchart

A decision tree classification algorithm is added to the improved DTBFT consensus algorithm, which collects the node’s reputation points, number of downtimes, number of consecutive consensus times, number of incorrect communications, and activity after each round of consensus is completed using these as feature attributes, and senior nodes, intermediate nodes, junior nodes, and culling as category attributes. In Hyperledger Fabric federation chain a channel, an anchor node is a node defined in an organization that has joined to the channel. Since the algorithm is improved for Hyperledger Fabric federation chain so the statistics of node attributes are taken care of by the anchor nodes in the federation chain.

C4.5 The decision tree construction steps are as follows: 1)

Calculate the information entropy. Information entropy can measure whether the sample set belongs to the same category. According to the training set, the category information entropy is calculated as: (17)Info(D)=−∑k=14Pklog2Pk$$Info(D) = - \sum\limits_{k = 1}^4 {{P_k}} {\log_2}{P_k}$$

Among them: (20)IV(a)=−∑v=15|Dv||D|log2|Dv||D|$$IV(a) = - \sum\limits_{v = 1}^5 {\frac{{\left| {{D^v}} \right|}}{{|D|}}} {\log_2}\frac{{\left| {{D^v}} \right|}}{{|D|}}$$

The DTBFT algorithm retains the stages of the PBFT algorithm, removes the communication process between consensus nodes, reduces the network bandwidth, and the consensus nodes are selected as intermediate nodes within the system to act as a guarantee of the reliability of the nodes of the system and the security of the system.

Request phase: client C sends a <REQUEST, O, T, C> to master node P, O indicating the state machine for executing the request, T indicating the timestamp, and C indicating the number of the client.

Prepare phase: master node P receives a proposal numbered N from the client, generates Prepare proposal <<PREPREPARE, V, N, DIGEST>, OUTCOME>CREDIT, MESSAGE>> to be sent to all consensus nodes, V denotes the trial view number, N denotes the proposal number received by the master node, DIGEST denotes the summary of MESSAGE, OUTCOME denotes the result of hash calculation of CREDIT, CREDIT denotes the reputation points of this node, and MESSAGE denotes the request information of the client.

The view switching protocol of the original algorithm is to select the master node from all the nodes within the system, and the improved view switching protocol is to select the master node from all the advanced nodes within the system, and the remaining advanced nodes will be used as candidate nodes to take over the identity of the master node when the master node has an error. According to the size of the reputation points |RH|$$\left| {{R_H}} \right|$$ advanced nodes that have been categorized within the system are numbered according to the points, {0,1,⋯,|RH|−1}$$\left\{ {0,1, \cdots ,\left| {{R_H}} \right| - 1} \right\}$$ and the smaller the serial number the higher the probability of being selected as the master node: (21)P=Vmod|RH|$$P = V\ \bmod \ \left| {{R_H}} \right|$$

Where P denotes the serial number of the finally elected master node; V denotes the number of the current view; and |RH|$$\left| {{R_H}} \right|$$ denotes the number of all advanced nodes within the system. The trigger conditions of the improved view switching protocol are: 1)

The master node fails to receive 2F + 1 a readiness message within a fixed time t₁ (F denotes the maximum number of nodes allowed to fail among all nodes);

Experiment 1: Comparison of algorithm latency performance before and after optimization

In order to compare with the PBFT consensus algorithm before optimization, this paper selects the number of transactions with block size in the range of [50, 1000] for simulation testing, and calculates the average value after 10 experiments to get the transaction latency under different block sizes, and the results are shown in Fig. 4. When the block size is 50, the latency of PBFT and this paper’s algorithm is 23ms and 14ms respectively. The real-time delay is 779ms and 714ms when the block size is 1000. Regardless of the block size, the latency of the algorithm in this paper is under PBFT.

Figure 4.

Time delay in different block size transactions

From the experimental results, it is easy to see that the transaction latency of both the PBFT consensus algorithm and the method in this paper increases continuously with the increment of the block size. The reason for this is that under the premise that the blockchain network bandwidth and Docker processing capacity remain unchanged, the increase in the amount of data requested by the client transaction will make the consensus node message broadcasting, hash processing and other time increases. However, it can also be compared and found that the optimized PBFT consensus algorithm in this paper has a slightly lower average transaction determination time than the PBFT consensus algorithm in the case of the same block size. The reason is due to the fact that this paper’s method reaches the distributed consistency consensus problem through the consensus node voting weights, and only through a few important consensus nodes can complete a consensus verification work, thus improving the transaction delay performance.

Experiment 2: Comparison of algorithmic transaction throughput before and after optimization

In this paper, we simulate four blockchain systems running at different time intervals of 5s, 10s, 20s and 40s. each time interval is experimented 10 times, and the results are shown in Fig. 5. Where (a)~(d) are the results of experiments with time intervals of 5s, 10s, 20s and 40s, respectively.

Figure 5.

The total number of transactions in different time intervals

It can be seen that in the case of different time intervals, the throughput of this paper’s algorithm is basically higher than the PBFT consensus algorithm. When the time interval is 40s, the throughput of the blockchain system of this paper’s algorithm leads the PBFT algorithm by more than 12,000 blocks.

From the experimental test results, it is not difficult to find that, with the increasing time interval of the blockchain system, the throughput of the blockchain system based on the PBFT consensus algorithm before and after optimization will increase. The reason for this is that the larger time interval means that the amount of transaction data contained in the newly generated block increases.

Then the average of 10 experiments for each simulation time interval is taken as the transaction throughput of the PBFT consensus algorithm before and after optimization in this paper. With the change of time interval, the blockchain system throughput test results based on these two Byzantine fault-tolerant consensus algorithms are shown in Fig. 6.

Figure 6.

TPS and time interval relations

From the figure, it can be concluded that the PBFT consensus algorithm optimized by C4.5 decision tree in this paper has a slightly higher TPS value than the PBFT consensus algorithm at the same time interval. The reason is that the consensus nodes in this paper’s algorithm are first classified by the C4.5 decision tree classification model, so that the consensus nodes with high trust degree are prioritized to act as the master node, thus avoiding the situation that the system can not operate normally due to the non-honest nodes acting as the master node.

In addition, the introduction of the voting value to achieve distributed consistency consensus work, only through a few important consensus nodes can be completed once the consensus verification work, thus shortening the verification waiting time of the client’s transaction request, and increasing the transaction throughput per unit of time.

The average value of these 40 experiments is selected as the TPS value of the optimized PBFT consensus algorithm and compared with the throughput of other mature blockchain platforms at present, and the comparison results are shown in Table 2. The TPS of this paper’s algorithm is 1272, which is higher than the remaining mainstream blockchain consensus algorithms.

Experiment 3: Comparison of fault tolerance of algorithms before and after optimization

In order to verify that the optimized PBFT consensus algorithm using C4.5 decision tree has a greater advantage in fault tolerance performance. In this paper, in the eight consensus nodes on the Hyperledger Fabric-based blockchain simulation test platform, the values of f are simulated to be 0, 1, 2, 3, 4, 5 to carry out experimental comparisons, and each value of f is experimented for 10 times, and the average value of the 10 experiments is taken as the final results of the experiment, and the experimental results are compared with those of the PBFT consensus algorithm before optimization. Among them, the system transaction confirmation time (the generation time of a new block, the block size of 100 strokes/block is taken for this part of the experiment) and transaction throughput are used as the evaluation criteria of whether the blockchain system based on the PBFT consensus algorithm before and after the optimization can complete the consistency consensus work normally. TPS versus number of faulty nodes is shown in Fig. 7. The time delay versus the number of faulty nodes is shown in Fig. 8.

Figure 7.

The relationship between TPS and error node number

Figure 8.

The relationship between delay and error node number

In the blockchain system based on PBFT consensus algorithm, if more than 2 consensus nodes out of 8 consensus nodes are wrong, the TPS value will be reduced to 0; the time delay also tends to positive infinity, that is to say, it is impossible to complete the consistency consensus validation work normally in a limited time. However, in the optimized PBFT consensus algorithm test of this paper, if more than 3 consensus nodes in 8 consensus nodes have errors, the TPS value will drop to 0. This paper’s method can tolerate more consensus node errors in the blockchain network compared with the traditional PBFT consensus algorithm.