System and method for self-healing in decentralized model building for machine learning using blockchain

The self-healing of nodes is achieved through blockchain technology, which solves the problem of poor fault tolerance of machine learning model construction in a limited distribution environment, improves the accuracy and reliability of the model, and ensures the stability of the system.

CN112955874BActive Publication Date: 2024-12-03HEWLETT PACKARD ENTERPRISE DEV LP
View PDF 0 Cites 0 Cited by

Patent Information

Application Number
CN202080005789.3
Authority / Receiving Office
CN · China
Patent Type
Patents(China)
Current Assignee / Owner
Priority Date
2019-02-21
Filing Date
2020-02-20
Publication Date
2024-12-03
Estimated Expiration
2040-02-20

AI Technical Summary

Technical Problem

In a finite distribution computing environment, machine learning model construction is difficult to achieve fault tolerance, resulting in data loss in node failure and system learning ability degradation, affecting the accuracy and reliability of the model.

Method used

Blockchain technology is used to realize node self-healing. Through automatic synchronization and state perception functions, faulty nodes are detected and corrected, and faulty nodes are reintegrated into the model construction process to ensure the fault tolerance and learning ability of the model.

Benefits of technology

The fault tolerance of the machine learning model is realized in a finite distribution environment, avoiding data loss caused by node failure and degradation of system learning capabilities, improving the accuracy and reliability of the model, and reducing dependence on network resources.

✦ Generated by Eureka AI based on patent content.

Smart Images

  • Figure CN112955874B_ABST
    Figure CN112955874B_ABST
Patent Text Reader

Abstract

Decentralized machine learning for building models is performed at the node where the local training dataset is generated. The blockchain platform can be used to coordinate decentralized machine learning (ML) over a series of iterations. For each iteration, a distributed ledger can be used to coordinate nodes that communicate via the blockchain network. The nodes can include self-healing features to recover from failure conditions within the blockchain network in a manner that does not negatively impact the overall learning capabilities of the decentralized ML system. During self-healing, the node can determine that the local ML state is inconsistent with the global ML state and trigger a corrective action to restore the local ML state. Thereafter, the node can generate a blockchain transaction indicating that it is out of sync with the latest training iteration and notifying other nodes to reintegrate the node into the ML.
Need to check novelty before this filing date? Find Prior Art

Description

Background Art

[0001] Effective model building requires a large amount of data. Although distributed computing has been developed to coordinate large computing tasks using multiple computers, it is difficult to apply it to large-scale machine learning ("ML") problems. Several practical problems arise in distributed model building, such as coordination and deployment difficulties, security issues, the impact of system latency, fault tolerance, parameter size, etc. Although these and other issues can be handled in a single data center environment where computers can be strictly controlled, moving model building from outside the data center to a truly decentralized environment will bring these challenges and additional challenges. For example, a system for decentralized ML can be in a limited distributed computing environment with a limited number of computing nodes. Therefore, compared with open methods that can theoretically use an unlimited number of nodes (e.g., federated ML), a relatively small number of nodes can participate in ML-based processes in these computing environments. In such a computing environment with a limited number of participating nodes, the contribution of each node in decentralized ML may be more valuable. Therefore, it may be desirable to further adapt decentralized model building to achieve fault tolerance. Fault tolerance can prevent the complete loss of a node (or node group) throughout the decentralized model building process and mitigate the impact of a failed node (or node group) on the overall learning ability of the ML system. BRIEF DESCRIPTION OF THE DRAWINGS

[0002] According to one or more various embodiments, the present disclosure is described in detail with reference to the following drawings. These drawings are provided for illustration purposes only and merely depict typical or exemplary embodiments.

[0003] Figure 1 Depicted is an example of a decentralized model building system for machine learning (ML) using blockchain including self-healing of participant nodes, in accordance with some embodiments.

[0004] Figure 2A-2B The diagram illustrates the Figure 1 An example of nodes in the decentralized model building system communicating based on self-healing technology is shown.

[0005] Figure 3 Illustrated is a diagram of a system configured to perform Figure 2A-2B An example of a node with the self-healing technology shown in .

[0006] Figure 4 is an operational flow diagram illustrating an example of an iterative process for model building for ML using blockchain, according to some embodiments.

[0007] Figure 5 is a diagram illustrating that according to some embodiments, Figure 2A-2BAn operational flow chart of an example of a self-repair process performed by a node is shown in FIG.

[0008] Figure 6 An example computer system related to embodiments of the disclosed technology is illustrated, which can be used to implement self-healing in decentralized model building for ML using blockchain.

[0009] The drawings are not exhaustive and do not limit the disclosure to the precise forms disclosed. DETAILED DESCRIPTION

[0010] Various embodiments described herein are directed to methods and systems for self-healing of computer nodes in decentralized model building for machine learning (ML) using blockchain. In certain distributed computing environments, such as enterprise systems (e.g., computer networking systems operating in a domain controlled by a particular organization or enterprise), there may be a limited number of computing resources that may be present or otherwise available. Due to many variable factors, such as data privacy issues, organizational structure, restricted network access, computer inventory, etc., the distributed computing environment may be limited to a relatively small number of computers. For example, only a portion of the computers in the enterprise network may be authorized to access the information required to train a data set in ML. Therefore, data privacy restrictions associated with the enterprise environment may further limit the number of computers in the enterprise network that may be eligible to participate in ML. Typically, as disclosed herein, a limited distributed computing environment typically has fewer computing nodes that can be contributors in decentralized model building. In order to enable certain current ML techniques to operate with the expected accuracy using computers of a limited distributed computing environment, an implicit requirement is that substantially all participating nodes are available and contribute their respective learning during ML model building. Additionally, in order to maintain ideal accuracy for ML in a limited distributed computing environment, these existing ML methods may further require almost immediate recovery of any failed nodes (e.g., short node downtime). Continuing ML in the event of a participating node failure may corrupt the data used in the entire system (e.g., partial learning, data loss in the training data set) because ML is a strictly collaborative process. Therefore, a single down node may have a negative impact on the learning of other nodes, which may eventually lead to the degradation of the corresponding local model and reduce the overall effectiveness of the system. In some cases, the model may gradually degrade in a manner proportional to the downtime of the participating nodes. For example, in a model building process with a limited number of participants, the longer the node is missing, the more decisive the impact on ML may be. In the best case, maintaining the normal function of each computer in the system can avoid these problems and ensure accurate machine learning. Nevertheless, at least one computer participating in model building will inevitably encounter unexpected failures in real-world scenarios.

[0011] As described above, implementing fault tolerance at the node level in decentralized model building for ML can address some potential disadvantages associated with limited distributed computing environments. For example, if a node loses communication with the network, implementing fault tolerance at each node can maintain the expected accuracy of the ML model even within a limited distributed computing environment. According to an embodiment, participating nodes that can be restarted after experiencing intermittent failures can use the disclosed self-healing techniques to automatically correct and reintegrate into the decentralized machine learning process. Therefore, the disclosed self-healing aspects provide a decentralized model building process that can tolerate node failures.

[0012] In addition, some existing ML methods are used in environments that are not limited to limited distributed computers. For example, many federated systems for ML have such a setting that the centralized model is trained using training data distributed on a large number of computing devices and usually on a public or unrestricted communication network. For example, federated ML can be applied to mobile or Internet of Things (IoT) scenarios, in which the model is trained based on information processed in hundreds of thousands (in some cases millions) of devices with network connectivity. Due to the large number of ML participants and open access to data, the loss of a few nodes in a federated ML application has less impact on the overall learning ability of the system than in a limited distributed computing environment. Therefore, many of these existing ML methods cannot achieve fault tolerance at the node level. Although high accessibility may be advantageous for the general concept of ML, there are situations where a federated ML method may not be required (such as maintaining data privacy). In these cases, it can be self-repairing.

[0013] refer to Figure 1 , shows an example of a decentralized model building system 100 for machine learning (ML) using blockchain. According to an embodiment, the system 100 performs decentralized parallel ML at nodes 10a-10g through multiple iterations in a blockchain network 110. The system 100 may include a model building blockchain network 110 (also referred to as a blockchain network 110), which includes multiple computing nodes or computer devices. Generally, the blockchain network 110 can be a network of nodes 10a-10g using a consensus mechanism to update a blockchain distributed across multiple parties. The specific number, configuration, and connections between nodes 10a-10g may vary. In this way, Figure 1 The arrangement of the node 10e shown in the figure is for illustration purposes only. A node such as the node 10e may be a fixed or mobile device. An example of further details of the node 10e will now be described. Although only one of the nodes 10e is illustrated in detail in the accompanying drawings, each of the nodes 10a-10g may be configured in the manner shown.

[0014] Figure 1 It is also depicted that the node 10e as disclosed herein is configured to implement self-healing techniques. By using blockchain in ML, embodiments can leverage the automatic synchronization capabilities and state-aware properties associated with distributed ledgers to implement self-healing. In some cases, each node 10a-10g in the system 100 can be similarly configured to perform self-healing. Furthermore, by including self-healing features at the nodes 10a-10g, the system 100 can continue model building even in the presence of intermittent failures. For example, Figure 1 It is illustrated that node 10e may experience a connection interruption, wherein a previously established connection (shown by a dashed line) from node 10e to other nodes 10a-10d, 10f, and 10g in network 110 may temporarily fail. For example, the wireless antenna of node 10e may fail, resulting in the loss of its peer-to-peer wireless link between nodes 10d, 10f, and 10g. As a result, node 10e may be communicatively disconnected from other nodes 10a-10d, 10f, and 10g in system 100. In some cases, the connection interruption may cause node 10e to be disconnected from the entire blockchain network 110. It should be understood that for the purpose of illustration, the connection interruption is described as a failure scenario, and as disclosed, other forms or one or more failures related to the node may also cause node 10e to initiate self-healing techniques. Examples of failure scenarios that may require node 10e to perform self-healing to return to normal ML operation include, but are not limited to: power outage; software failure; computer system crash; computer system restart, etc. For the purpose of discussion, a node that will experience any of the above failure scenarios in whole or in part or that is otherwise unable to participate in the ML process may be referred to as a "down" node or a "self-healing" node hereinafter. Figure 1 The node 10e in FIG. 1 is illustrated as a self-repairing node.

[0015] By way of example, in some existing ML systems that do not utilize blockchain technology, there are many challenges associated with implementing self-healing. For example, the connections between nodes 10a-10g in system 100 can be implemented entirely using a peer-to-peer network. In most cases, peer connections are established temporarily. Therefore, it may be difficult for other nodes 10a-10d, 10f, and 10g in blockchain network 110 to detect in a robust manner that node 10e has become unavailable (as opposed to the expected disconnection of the peer link) due to experiencing a failure (such as a connection interruption). Similarly, node 10e may not be equipped to detect for itself that it has encountered a failure. For example, in the case where node 10e has been restarted after a connection interruption, node 10e may not have the ability to determine that a connection interruption has previously occurred. However, blockchain includes a structure, namely, a distributed ledger 42, which is capable of maintaining the state of each node 10a-10g in system 100. Therefore, the state awareness provided by the blockchain can be used during self-healing to allow other nodes in system 100 to detect down nodes (e.g., experiencing a failure). Even further, the blockchain is utilized to enable the node 10e to have the ability to be self-aware of encountering a failure condition.

[0016] Additionally, as previously described, a failure at a single node may affect the entire model building process. Therefore, various corrective actions may need to be performed to resolve these issues before allowing the self-healing node to re-participate in the model building process. Blockchain technology includes a synchronization mechanism that can be applied to resynchronize the restarting node 10e with the system 100, thereby further enhancing the self-healing aspect of the embodiment. Therefore, the synchronization protocol can be performed as part of the disclosed self-healing technology. As shown in reference Figure 2A-2B As described in more detail, in general, synchronization ensures that self-healing nodes are properly reintegrated into the decentralized model building process to maintain the overall effectiveness of ML.

[0017] According to an embodiment, the node 10e includes a self-repair module 47. The self-repair module 47 can program the node 10e to perform various functions that allow the node 10e to automatically correct and reintegrate into the decentralized model building of the system 100 according to the self-repair techniques described herein. In addition, according to various implementations, the node 10e and components described herein can be implemented in hardware and / or software that configures the hardware. The self-repair module 47 is shown as a modular part of the rules implemented by the smart contract 46. Specifically, as previously described, the rules encoded by the self-repair module 47 can enable the decentralized model building to operate in a fault-tolerant manner.

[0018] Node 10e may include one or more sensors 12, one or more actuators 14, other devices 16, one or more processors 20 (also interchangeably referred to herein as processor 20, (multiple) processors 20, or processor 20 for convenience), one or more storage devices 40, and / or other components. Sensors 12, actuators 14, and / or other devices 16 may generate data that is locally accessible to node 10e. Such data may not be accessible to other participant nodes 10a-10d, 10f, and 10g in the model building blockchain network 110.

[0019] Figure 1 It is shown that (multiple) storage devices 40 can store: distributed ledgers 42; models 44; and (multiple) smart contracts 46 including self-healing models 47. The distributed ledger 42 may include a series of data blocks, which at least reference another block, such as a previous block. In this way, the data blocks can be linked together. The distributed ledger 42 can store blocks indicating the state of the node 10e during the iteration related to its machine learning. Therefore, the distributed ledger 42 can store an unchanging record of the state transitions of the node 10e. In this way, the distributed ledger 42 can store the current state and historical state of the model 44. However, it should be noted that in some embodiments, some collections of records, models, and smart contracts from one or more other nodes may be stored in the distributed ledger 42.

[0020] Distributed ledger 42, transaction queue, model 44, smart contract 46 and / or other information described herein may be stored in various storage devices such as storage device 40. Other storage methods may also be used depending on specific storage and retrieval requirements. For example, various information described herein may be stored using one or more databases. Other databases (such as Informix TM , DB2 (Database 2)) or other data storage methods, including based on files, or query formats, platforms or resources, such as OLAP (Online Analytical Processing), SQL (Structured Query Language), SAM (Storage Area Network), etc. The database may include one or more such databases residing in one or more physical devices and one or more physical locations. The database may store multiple types of data and / or files and associated data or file descriptions, management information or any other data.

[0021] Node 10e may store training data sets locally in (multiple) storage devices 40. As described herein, model 44 may be trained locally at node 10e based on locally accessible data such as training data sets. Model 44 may then be updated based on model parameters learned at other participant nodes 10a-10d, 10f, and 10g shared via blockchain network 110. The properties of model 44 may be based on the specific implementation of node 10e itself. For example, model 44 may include trained parameters related to autonomous vehicle features (such as sensor information related to object detection), dryers related to drying time and control, network configuration features for network configuration, security features related to network security (such as intrusion detection), and / or other context-based models.

[0022] Smart contracts 46 may include rules that configure node 10e to operate in certain ways with respect to decentralized machine learning. For example, the rules may specify deterministic state transitions, when and how to elect a master node, when to initiate an iteration of machine learning, whether a node is allowed to enroll in an iteration, the number of nodes required to agree to a consensus decision, the percentage of voting nodes required to agree to a consensus decision, and / or other actions that node 10e may take for decentralized machine learning.

[0023] The processor 20 may be programmed by one or more computer program instructions. For example, the processor 20 may be programmed to execute an application layer 22, a machine learning framework 24 (illustrated and also referred to as an ML framework 24), an interface layer 26, and / or other instructions for performing various operations, each of which is described in more detail herein. The processor 20 may obtain other data that is locally accessible to the node 10e but not necessarily accessible to other participant nodes 10a-10d, 10f, and 10g. Such locally accessible data may include, for example, private data that should not be shared with other devices. As disclosed herein, model parameters learned from private data may be shared according to the parameter sharing aspects of an embodiment.

[0024] The application layer 22 can execute applications on the node 10e. For example, the application layer 22 can include a blockchain agent (not shown) that programs the node 10e to participate in and / or act as a master node in decentralized machine learning across the blockchain network 110 as described herein. Each node 10a-10g can be programmed using the same blockchain agent, thereby ensuring that each node operates according to the same decentralized model building rule set (such as a rule set encoded using a smart contract 46). For example, the blockchain agent can program each node 10 to act as a participant node and a master node (if it chooses to play this role). The application layer 22 can perform machine learning with the help of an ML framework 24.

[0025] The ML framework 24 may train a model based on data that is locally accessible at the node 10e. For example, the ML framework 24 may generate model parameters based on data from sensors 12, actuators 14, and / or other devices or data sources that the node 10e has access to. In one implementation, the ML framework 24 may use a machine learning framework, but other frameworks may also be used. In some of these implementations, a third-party framework application programming interface (“API”) may be used to access certain model building functions provided by the machine learning framework. For example, the node 10e may perform a call to a machine learning framework (e.g., TensorFlow TM ) API call.

[0026] The application layer 22 may use the interface layer 26 to interact with and participate in the blockchain network 110 for decentralized machine learning across multiple participant nodes 10a-10g. The interface layer 26 may communicate with other nodes using the blockchain by, for example, broadcasting blockchain transactions, and for selected master nodes as described elsewhere herein, writing blocks to the distributed ledger 42 based on those transactions and based on the activities of the master nodes.

[0027] Model building for ML can be pushed to multiple nodes 10a-10g in a decentralized manner, thereby addressing changes in input data patterns, scaling the system, and coordinating model building activities across nodes 10a-10g. Moving model building closer to where the data is generated or otherwise accessible, i.e., at nodes 10a-10g, efficient real-time analysis of data can be achieved where the data is generated, without having to consolidate the data in a data center and the associated problems of doing so. Without the need to consolidate all input data into one physical location (the "core" of a data center or IT infrastructure), the disclosed systems, methods, and non-transitory machine-readable storage media can reduce the time (e.g., model training time) to adapt the model to changes in environmental conditions and make more accurate predictions. Therefore, whether in an autonomous vehicle context and implementation, or in other IoT or network-connected environments, the application of the system can become truly autonomous and decentralized.

[0028] According to various embodiments, decentralized ML may be accomplished via multiple training iterations coordinated between multiple computer nodes 10a-10g. According to an embodiment, ML is facilitated using a distributed ledger of a blockchain network 110. Each of the nodes 10a-10g may register with the blockchain network 110 to participate in a first iteration of training a machine learning model at a first time. Each node 10a-10g may participate in a consensus decision to register another computing node to participate in the first iteration. The consensus decision may only apply to the first iteration, and a second physical computing node may not be registered to participate in subsequent iterations.

[0029] In some cases, a specified number of nodes 10a-10g need to be registered for training iterations. Thereafter, each node 10a-10g may obtain a local training data set that is locally accessible but inaccessible at other computing nodes in the blockchain network. Node 10e may train a first local model 44 based on the local training data set during the first iteration, and may obtain at least a first training parameter based on the first local model. Similarly, each of the other nodes 10a-10d, 10g, and 10f on the blockchain network 100 may train a local model, respectively. In this way, node 10e may train on data that is locally accessible but not shared with other nodes 10a-10d, 10f, and 10g. Node 10e may generate a blockchain transaction including an indication that the training parameters are ready to be shared, and may transmit or otherwise provide the training parameters to the master node. Node 10e may do this by generating a blockchain transaction that includes an indication and information (such as a uniform resource indicator address) indicating where the training parameters may be obtained. When some or all participant nodes are ready to share their respective training parameters, a master node (also referred to as a "master computing node") may write an indication to a distributed ledger. As described herein, the minimum number of participant nodes that are ready to share training parameters such that the master node writes an indication may be defined by one or more rules, which may be encoded in a smart contract.

[0030] Node 10e (in Figure 110e) may be temporarily unable to communicate via the blockchain network 110. In addition, the node 10e may not be able to transmit blockchain transactions to update its state during the connection interruption. In this case, the master node may determine that it has failed to receive blockchain transactions, in particular, from the node 10e. According to the disclosed self-healing technology, detecting the lost blockchain transactions may signal to the master node that the node 10e is down. Therefore, the blockchain at least allows the master node to know that the node 10e may be experiencing a failure that prevents the node 10e from communicating via the blockchain network 110. In some cases, the self-healing of the node 10e may be triggered by detecting the failure condition in this way. In addition, the down node 10e that cannot connect to its peers or the blockchain network 110 may not be able to share its local training parameters with other nodes 10a-10d, 10f, and 10g. During the connection interruption, the node 10e may also not receive updated training parameters from the blockchain. Therefore, even after the node 10e regains connection, the data local to the node 10e may be outdated. As an example, during a connection outage, parameters from the latest iteration may not have been successfully received by the node 10e. To prevent the injection of invalid data during the model building process, the self-repair module 47 can cause the node 10e to automatically perform synchronization with the system 100 to compensate for the data loss before it continues to participate in the decentralized model building process. As disclosed herein, self-repair allows the node 10e to automatically perform the actions required to be reintroduced into the ML. The automatic self-repair is performed by the node 10e so that it eliminates the need for a human operator, such as a network administrator, to manually perform the process of placing the node 10e back into the system 100 after a failure.

[0031] Figure 2A-2B An example of nodes 10a-10g in a blockchain network 200 communicating according to the self-healing technique described above is illustrated. FIG. 2A to FIG. 2B The diagram illustrates a self-repairing node 10e communicating in a manner that provides fault tolerance during model building (also referred to herein as machine learning or model training). For the purpose of illustration, the process is shown as a first stage (primarily in Figure 2A ), and the second phase after the self-repairing node 10e has been synchronized (mainly in Figure 2B ). Figure 2A-2B Also depicted is a distributed ledger 42 that is global to the blockchain network 200. Additionally, Figure 2A-2BMaster node 10g is shown. Each of the other nodes registered to participate in the iteration (i.e., nodes 10a-10d and 10f) is referred to herein as a "participant node." In some cases, as described herein, the minimum number of participant nodes that must be prepared to share training parameters so that master node 10g writes an indication may be defined by one or more rules, which may be encoded in a smart contract.

[0032] As previously described, the distributed ledger 42 may contain information indicating the state of each of the nodes 10a-10g. Thus, the distributed ledger 42 may be used to enable state awareness for the nodes 10a-10g on the blockchain network 200. Figure 2A , the first stage may include participant nodes 10a-10d and 10f using a local training data set to train their corresponding local models. For example, each of the participant nodes 10a-10d and 10f may query a local copy of the distributed ledger 42 to obtain information about the current state of other nodes in the blockchain network. Participating nodes 10a-10d and 10f may actively contribute during iterations of model building. Iterations may involve participating nodes 10a-10d and 10f with training data sets being locally accessible to participant nodes, but inaccessible to other nodes. In this way, each participant node 10a-10d and 10f may generate model parameters obtained from the local training data set, which are referred to as shared parameters in this article. As a result, participant nodes 10a-10d and 10f may each share their corresponding model parameters with other participants in the blockchain network 200 as shared parameters. For example, each participant node 10a-10d and 10f may communicate its shared parameters to a master node 10g, which is selected from nodes in the blockchain network 200. Furthermore, each of the participant nodes 10a - 10d and 10f may update its current ML state in the distributed ledger 42 .

[0033] like Figure 2A As shown, a master node 10g may be included in the blockchain network 200. The master node 10g may generate a new transaction to be added to each copy of the distributed ledger as a ledger block based on, for example, an indication that one of the participating nodes 10a-10d and 10f is ready to share its shared training parameters. The master node 10g may be selected from the other nodes 10a-10e by consensus decision, or may be selected simply based on the first node registered into the iteration. Figure 2ANodes 10a-10d and 10f are illustrated as participant nodes in the blockchain network 200. According to an embodiment, the participant nodes 10a-10d and 10f can train local models using training data that is locally accessible at the node but inaccessible at another node. However, training parameters learned from such data by machine learning can be shared because the training parameters generally do not disclose the original data (which may contain sensitive information). When the training parameters are determined by the node, the node can broadcast an indication that it is ready to share the training parameters. For example, after the participant node 10a trains its local model using the training data, it can broadcast an indication via the blockchain network 200, which is received by at least the master node 10g. Subsequently, the participant node 10a can communicate its shared training data received by the master node 10g via the blockchain network 200. As a general description, the master node 10g can obtain shared training parameters from each participant node 10a-10f in the blockchain network 200, which is referred to as "parameter sharing" in this article.

[0034] During the above iterations, after a failure condition, the self-healing node 10e may be in the process of restarting itself. Figure 1 ), the self-repairing node 10e may not be able to communicate via the blockchain network 200. In some cases, the self-repairing node 10e may have been completely down previously. For example, the self-repairing node 10e may have crashed, causing it to lose all dynamic content that has not yet been communicated to the blockchain. Continuing with this example, in this scenario, before the node 10e can start the synchronization part of the process, it may be necessary to fully restart the node 10e. In other cases, in contrast to a failure, the self-repairing node 10e may be recovering from a network partition. A network partition can generally be characterized as a partial downtime of a node. As an example, when the self-repairing node 10e network is partitioned, it is operating normally, but cannot communicate with peer nodes in a way that allows it to participate in the collaborative ML process. In these cases, it may not be necessary to fully restart the self-repairing node 10e. After the network connection is reestablished, the self-repairing node 10e can begin synchronization. In some embodiments, the self-repairing node 10e is configured to automatically perform any necessary functions required to recover from the above-mentioned interruption, such as automatic restart. Once the node has recovered from the interruption, the blockchain layer of the node 10e can initiate a synchronization protocol as an aspect of its self-repair. As an initial step in synchronization, the self-healing node 10e may obtain blocks from the distributed ledger 42. This allows the self-healing node 10e to retrieve any blocks that may have been lost or compromised during the outage.

[0035] The self-repairing node 10e may update the local copy of the distributed ledger to obtain the global ML state 17 and the local ML state 18. As previously described, the distributed ledger 42 may maintain the current (e.g., based on the most recent iteration) global ML state 17 based on collaborative learning from system nodes, as well as the current local ML state 18 corresponding to the individual learning performed locally by each node. With respect to the self-repairing node 10e, its local ML state 18 maintained by the distributed ledger 42 should include data from the most recent iteration in which the node 10e is a participant. Therefore, the local ML state 18 reflects the state of the self-repairing node 10e synchronized by the blockchain before the failure. After the restart, all other participant nodes 10a-10d and 10f know that the self-repairing node 10e is in the state indicated by its local ML state 18 in the distributed ledger 42. Any other local ML state of the node 10e (inconsistent with the local ML state 18 maintained by the distributed ledger 42) may be the result of data corruption or obsolescence. Therefore, synchronization effectively overwrites this data with the local ML state 18 obtained from the distributed ledger to ensure that the state has been verified and is consistent across the entire blockchain.

[0036] also, Figure 2A It is illustrated that the self-repairing node IGe may generate a blockchain transaction 19 indicating that it is out of sync (“OOS”). By transmitting this “OOS” blockchain transaction 19, the self-repairing node signals to the network 200 that although it can recover from the fault condition, it has not yet completed the synchronization protocol for self-repair and it may be out of sync with the blockchain. An out-of-sync node may have machine learning data (including local models) that have not been updated by the latest learning iteration. As described above, the self-repairing technique can prevent the self-repairing node 10e from injecting corrupted or invalid data into the decentralized model building process by waiting until after the synchronization protocol to allow the node to contribute to ML. Specifically, the self-repairing node 10e that writes the OOS blockchain transaction 19 to the distributed ledger 42 signals to other participant nodes 10a-10d, 10f and the master node 10g that it is not yet ready to share its learning (e.g., local training parameters) with the system. Therefore, the self-repairing node 10e is still gradually reintroduced into the system and is not included in the current model building iteration.

[0037] Afterwards, as in Figure 2A As seen in FIG. 1 , the self-repairing node 10e can perform a comparison between the global ML state 17 and the local ML state 18. The comparison allows the self-repairing node 10e to determine whether the local data from its previous learning is synchronized or up-to-date with the rest of the system. The self-repairing node 10e can verify, for example, whether there is a consistency between the state of its local model and the state of the latest model building iteration that has been collaboratively performed by the nodes of the blockchain network 200. Specifically, Figure 2A The diagram illustrates a situation where the self-repairing node 10e determines that there is an inconsistency between the global ML state 17 and the local ML state 18. The inconsistency between the global ML state 17 and the local ML state 18 may indicate that the local ML state is invalid and corrective action needs to be taken to synchronize with other nodes of the blockchain network 110. According to the disclosed self-repairing technology, once the self-repairing node 10e has identified the inconsistency between the global ML state 17 and the local ML state 17, it can automatically perform various corrective measures to restore the state of the node 10e to achieve consistency.

[0038] Figure 2A It is shown that as a corrective action, the self-repairing node 10e can obtain the merged training parameters 15g generated from the latest model building iteration. The merged training parameters 15g can be used according to the parameter sharing technology of the decentralized model building system. For example, as described above, the participant nodes 10a-10d and 10f can share the training parameters corresponding to their respective local models. Subsequently, the master node 10g can combine the shared parameters from the participant nodes 10a-10d and IGf to generate the merged training parameters 15g for the latest iteration. When generating the merged training parameters 15g, the master node IGg can broadcast an indication that the merged training parameters are available to the blockchain network 200.

[0039] The master node 10g may broadcast an indication that it has completed generating the merged training parameters 15g by writing a blockchain transaction indicating the state change. Such a state change (in the form of a transaction) may be recorded in the distributed ledger 42 as a block with such an indication. During iterations, the participating nodes 10a-10fd and 10f may periodically monitor the distributed ledger 42 to determine whether the master node 10g has completed the merge, and if so, obtain the merged training parameters 15g. Similarly, during synchronization, the self-repairing node 10e may automatically query the distributed ledger 42 due to the discovery during which its local ML state 18 is inconsistent with the blockchain network. The merged training parameters 15g may be obtained by the self-repairing node 10e. The self-repairing node 10e may then apply the merged training parameters 15g to its local model and then update its state, which is written to the distributed ledger 42. As a result of the update, the local ML state 17 should be able to be restored to a point consistent with the global ML state 18. It should be understood that although reference is made to Figure 2A Parameter sharing is discussed as an example of corrective action, but the self-healing technology can perform different forms of corrective actions as needed, allowing the self-healing node 10e to update its local state and achieve synchronization with the blockchain network 200. Figure 5 Details related to corrective actions that may be implemented by the self-recovery aspects of the embodiments are discussed.

[0040] In some cases, the master node 10g indicating that it has completed the merge also releases its status as a master node for iteration. In the next iteration, a new master node may (but not necessarily) be selected. Training may be iterated until the training parameters converge. Once the training parameters no longer converge, the training iteration may be restarted, thereby continuously improving the model as needed with the help of the blockchain network.

[0041] Reference now Figure 2B , showing the second phase of communication. The second phase can generally be described as communication within the blockchain network 200 after the self-healing node 10e has been synchronized. Figure 2B It is illustrated that the second phase may involve ensuring that the local ML state 18 is consistent with the global ML state 17. In some cases, this determination may include performing another comparison between the global ML state 17 and the local ML state 18 after the corrective action is completed. Consistency indicates that the self-repairing node 10e is now in a consistent state with other nodes on the blockchain network 200. After the restart, the data at the self-repairing node 10e is now up to date and based on the latest model build iteration performed by the system and maintained by the distributed ledger 42. Restoring the local state of the self-repairing node 10e may indicate that the synchronization of the node 10e with the blockchain network 200 was successfully completed. After the self-repairing node 10e is synchronized, the node 10e may mark itself as in sync (“IS”) in the distributed ledger 42. Figure 2B It is shown that the self-healing node 10e can generate a blockchain transaction 20 indicating that it is in sync. By transmitting this "1-S" blockchain transaction 20, the self-healing node 10e signals to the network 200 that it has corrected any potential effects of the failure and can be reintroduced into the model building process. According to an embodiment, the "1-S" blockchain transaction 20 indicates to the master node 10g that the self-healing node 10e is now ready to share its learning as a participant node during successive iterations of model building.

[0042] Because decentralized machine learning as described herein occurs over multiple iterations, and different sets of nodes can register to participate in any one or more iterations, decentralized model building activities can be dynamically scaled as the availability of nodes changes. For example, even if an autonomous car computer is online (such as operating) or offline (such as turning off the car engine ignition), the system can continuously perform machine learning iterations at available nodes. When vehicles are online, using a distributed ledger, they can receive updated versions of the distributed ledger from, for example, peer vehicles, and obtain the latest parameters learned while the vehicle was offline.

[0043] Furthermore, dynamic scaling does not result in degradation of model accuracy. By using a distributed ledger to coordinate activities and using smart contracts to enforce synchronization by not allowing dead or uninitialized nodes to participate in iterations, the stale gradient problem can be avoided. Decentralized ledgers and smart contracts (such as Figure 1 The use of decentralized applications (as shown) can also make the system fault-tolerant. By dynamically scaling participant nodes and synchronizing learned parameters, node restarts and other downtime can be seamlessly handled without losing model accuracy. In addition, building applications to implement ML models for experiments can be simplified because decentralized applications are independent of the network topology and node roles in the system.

[0044] Reference now Figure 3 , illustrates a schematic diagram of a node 10 configured to participate in an iteration of machine learning using a blockchain. Figure 3 An example configuration of a node 10 is shown, and the node 10 includes a self-repair mode 47 for implementing the self-repair aspects disclosed herein. In the example shown, the self-repair module 47 can be a modular part of the rules implemented by the smart contract 46. As described above, the smart contract 46 can include rules that configure the node 10 to operate in certain ways relative to decentralized machine learning. Specifically, the rules encoded by the self-repair model 47 can program the node 10 to perform self-repair in a manner that reintroduces the node 10e into the decentralized model building process as described above. For example, the smart contract 46 can cause the node 10 to use the application layer 22 and the distributed ledger 42 to coordinate parallel model building during iterations with other participant nodes. The application layer 22 may include a blockchain agent that initiates model training. Further, the smart contract 46 can configure the node 10 to communicate shared parameters (as opposed to raw data).

[0045] The interface layer 26 may include a message passing interface that is used by the node 10 to communicate with other participant nodes via the network. As an example, the interface layer 26 provides a method for allowing the node 10 to send its shared parameters (such as Figure 2BThe interface 206 may be configured as a secure hypertext transfer protocol (“HTTPS”) microserver 204. Other types of messaging interfaces may also be used. The interface layer 26 may use a blockchain API 206 to make API calls to blockchain functions based on blockchain specifications. Examples of blockchain functions include, but are not limited to, reading and writing blockchain transactions 208 and reading and writing blockchain blocks to a distributed ledger 42. An example of a blockchain specification is the Ethereum specification. Other blockchain specifications may also be used. According to some embodiments, after a failure, the self-repair module 47 waits for the blockchain API 206 to be fully operational before initiating the self-repair techniques described herein. Thus, the self-repair module 47 prevents attempts to perform self-repair functions related to the blockchain, such as automatic synchronization.

[0046] The consensus engine 210 may include functionality that facilitates writing data to the distributed ledger 42. For example, in some cases, when the node 10 is operating as a master node (e.g., one of the participant nodes 10), the node 10 may use the consensus engine 210 to determine when to merge shared parameters from corresponding nodes, write an indication that its state 212 has changed as a result of merging shared parameters into the distributed ledger 42, and / or perform other actions. In some instances, as a participant node (whether or not a master node), the node 10 may use the consensus engine 210 to perform consensus decisions, such as whether to register the node to participate in a machine learning iteration. In this way, after data is written to the distributed ledger, consensus regarding certain decisions may be reached.

[0047] In some implementations, the packaging and deployment program 220 can package and deploy the model 44 as a containerized object. For example, but not limited to, the packaging and deployment program 220 can use the Docker platform to generate a Docker file including the model 44. Other containerization platforms can also be used. In this way, various applications at the node 10 can access and use the model 44 in a platform-independent manner. In this way, the model can not only be built based on the collective parameters from the nodes in the blockchain network, but also can be packaged and deployed in various environments.

[0048] Reference now Figure 4 To describe the model building iterations in more detail, Figure 4 An example of a process 400 for iterating model building using blockchain according to one embodiment of the systems and methods described herein is illustrated. Figure 4 As shown, operations 402-412 and 418 apply to participant nodes, while operations 414, 416, and 420 apply to the master node.

[0049] In operation 402, each participant node may register to participate in a model building iteration. In one implementation, a smart contract (e.g. Figure 3 The example (shown in Figure 1) may encode rules for registering nodes to participate in model building iterations. The rules may specify required credentials, valid state information, and / or other registration prerequisites. The required credentials may impose permissions on which nodes are allowed to participate in model building iterations. In these examples, the blockchain network may be configured as a private blockchain in which only authorized nodes are allowed to participate in iterations.

[0050] Authorization information and desired credentials may be encoded within a smart contract or other storage information available to nodes on the blockchain network. Valid state information may prohibit nodes that exhibit certain restricted semantic states from participating in iterations. Restricted semantic states may include, for example, nodes that have uninitialized parameter values, are new nodes that request to be registered into an iteration after the iteration begins (with other participant nodes in the blockchain network), failed nodes or restarted nodes, and / or other states that may contaminate or otherwise corrupt the model building iteration. Failed or restarted nodes may be placed in an iteration holding state so that they can synchronize their local parameters to the latest values, such as after the iteration is completed.

[0051] Once a participant node has been registered, the blockchain network can record the identity of the participant node, thereby knowing the identities of all participant nodes for iteration. Such recording can be done via entries in a distributed ledger. When strategic decisions are made, the identity of the participant node can be determined by a consensus engine (such as Figure 3 shown) for use.

[0052] The aforementioned registration feature can make the model building activity fault-tolerant because the topology of the model building network (i.e., the blockchain network) is determined at an iteration level. This allows deployment in real-world environments (e.g., self-driving cars) where the shape and size of the network can change dynamically.

[0053] In operation 404, each of the participant nodes may perform local model training on its local training dataset. For example, the application layer ( Figure 3 ) can be used with machine learning frameworks ( Figure 3As shown) docking to locally train the model on its local training dataset. In some cases, due to privacy restrictions, operation 404 may involve a biased data environment. Therefore, during operation 404, the complete dataset used to train the model locally at the node may include some private data, thereby making the complete dataset inaccessible at other participant nodes without compromising its privacy. The model building process 400 adopts parameter sharing technology, which enables the privacy of data to be preserved in the collaborative model building process 400. Additionally, parameter sharing allows the local model of the node to be updated using learning performed by other participant nodes in the blockchain network. Therefore, parameter sharing technology may be advantageous in failure scenarios where a node may be down and unable to participate in several model building iterations. For example, in the field of self-healing, a node that recovers from a failure can use shared training parameters from its peers (or merged training parameters from the master node) to update its local model instead of applying its local data that may be invalid. As shown in reference Figure 5 As discussed in more detail, parameter sharing may be used as a corrective action for resynchronizing self-healing nodes with the blockchain network.

[0054] In operation 406, each of the participant nodes may generate local parameters based on local training and may keep them ready to be shared with the blockchain network to achieve parameter sharing. For example, after the local training cycle is completed, the local parameters may be serialized into a compact package, which may be stored in a format similar to Figure 2A , or a smart contract may be used to share the parameters of a node with the rest of the blockchain network in the manner of the shared parameters shown in . Such sharing may be facilitated by making the shared parameters available for download and / or active upload via peer-to-peer or other data transfer protocols. In some embodiments, the smart contract may encode the rules for nodes to communicate or otherwise share their shared parameters.

[0055] In operation 408, each participant node may coordinate using a blockchain network check-in. For example, each participant node may signal to other participant nodes in the blockchain network that it is ready to share its shared parameters. Specifically, each participant node may use, for example, a blockchain API ( Figure 3 Blockchain transactions are written using a protocol (as shown) and broadcasted via a messaging interface and a blockchain API. Such blockchain transactions may indicate the state of a participant node (e.g., it is ready to share its local parameters), a mechanism for obtaining shared parameters, a location to obtain shared parameters, and / or other information that conveys the node's readiness or identifies how to obtain shared parameters from other participant nodes. Transactions may be queued in a transaction queue or transaction pool from which transactions are selected. In some examples, these transactions may be timestamped and selected from in a first-in, first-out ("FIFO") manner.

[0056] In operation 410, the participant nodes may collectively select a master node for the iteration. For example, the smart contract may encode rules for selecting a master node. Such rules may dictate how the participant nodes should vote to select a master node (for implementations in which nodes vote to select a master node). The rules may specify that before a master node should be selected, a certain number and / or percentage of participant nodes should be ready to share their shared parameters, thereby initiating the sharing phase of the iteration. However, it should be noted that the selection of the master node may occur before the participant nodes 10 are ready to share their shared parameters. For example, the first node to be enrolled in the iteration may be selected as the master node. In this way, the selection (or selection) of the master node itself may not trigger the transition to the sharing phase. Instead, the rules of the smart contract may specify a sharing phase (see Figure 2A Known as phase 1) should be initiated to ensure that the transition occurs in a deterministic manner.

[0057] In addition to or as an addition to the first node to be registered, the master node can be selected in a variety of ways. For example, a specific node can be predefined as a master node. When an iteration is initiated, a specific node can become a master node. In some of these instances, in the case where a specific node is unavailable for a given iteration, one or more spare nodes can be predefined to act as a master node. In other examples, a node can declare that it should not be a master node. This may be advantageous in a heterogeneous computing environment where nodes have different computing capabilities. An example is in a drone network, where a drone can declare that it should not be a master node, and a command center can be declared as a master node. In other examples, a voting mechanism can be used to select a master node. Such a vote can be governed by rules encoded in a smart contract. This may be advantageous in a homogeneous computing environment where nodes have similar computing capabilities, such as in an autonomous car network. Other ways of selecting a master node can be used according to specific needs and based on the disclosure of this article.

[0058] In operation 412, a participant node that is not a master node may periodically check the state of the master node to monitor whether the master node has completed the generation of the merged parameters based on the shared parameters generated locally by the participant node. For example, each participant node may check its local copy of the distributed ledger, within which the master node will record its state for iteration on one or more blocks.

[0059] In operation 414, the master node may enter a sharing phase in which some or all participant nodes prepare to share their shared parameters. For example, the master node may obtain shared parameters from participant nodes whose status indicates that they are ready to share. Using the blockchain API, the master node may identify transactions that (1) indicate that the participant nodes are ready to share their shared parameters and (2) have not been signaled in the distributed ledger. In some cases, transactions in the transaction queue have not yet been written to the distributed ledger. Once written to the ledger, the master node (with the help of the blockchain API) may delete the transaction from the transaction queue or otherwise mark the transaction as confirmed. The master node may identify the corresponding participant node that submitted the shared parameters and obtain the shared parameters (whose location may be encoded in the transaction). The master node may combine the shared parameters from the participant nodes to generate merged parameters for iteration based on the combined shared parameters ( Figure 2B ). It should be noted that the master node may have generated local parameters itself from its local training data set, in which case the master node may also combine its local parameters with the obtained shared parameters. Therefore, in a distributed process, the master node can combine all individual learnings from each participant node in the entire blockchain network. For example, operation 414 can be described as compiling the learned patterns from the trained local models at each participant node by merging the shared parameters. As described above, at operation 414, the master node can use the shared parameters from the trained model instead of using the original data used to build the model to aggregate the distributed learning. In one implementation, the master node can write the transaction as a block on the distributed ledger, for example using a blockchain API.

[0060] In operation 416, the master node may signal that the combination is complete. For example, the master node may transmit a blockchain transaction indicating its status (the blockchain transaction combines the local parameters into the final parameters). The blockchain transaction may also indicate where and / or how to obtain the combined parameters for iteration. In some cases, the blockchain transaction may be written to a distributed ledger.

[0061] In operation 418, each participant node may obtain the merge parameters and apply them to its local model. For example, the participant node may check its local copy of the distributed ledger to determine that the state of the master node indicates that the merge parameters are available. The participant node may then obtain the merge parameters. It should be understood that the participant node is able to obtain and then apply the combined learning associated with the merge parameters (derived from the local model) so that it eliminates the need to transmit and / or receive a complete training data set (corresponding to each local model). In addition, any private data that is local to the participant node and may be part of its complete training data set may remain protected.

[0062] In operation 420, the master node may signal that the iteration is complete and may relinquish control as the master node for the iteration. Such an indication may be encoded in the distributed ledger for other participant nodes to detect and transition to the next state (the next state may be applying the model to its specific implementation and / or preparing for another iteration).

[0063] By recording state on a distributed ledger and recording related functionality, a blockchain network can efficiently manage node restarts and dynamic scaling when the number of participant nodes available for participation is constantly changing (such as when nodes come online and offline, whether because nodes are turned on / off, connected / disconnected from a network connection, and / or other reasons why node availability may change).

[0064] Figure 5 An example of a process 500 at a node that can perform self-repair in a manner that provides fault tolerance during decentralized machine learning is illustrated. In some cases, the process 500 can be performed at least as previously described with reference to Figure 4 The process 500 is illustrated as a series of executable operations performed by a processor 501, which may be a node (e.g., a node) that may have experienced an intermittent failure (such as a connection interruption). Figure 1 501 performs the operations of process 500, thereby implementing the disclosed self-healing techniques. Process 500 may be automatically performed by the node after the node has recovered from the fault condition. For example, referring to Figure 1 In the connection interruption example, once the node determines that the wireless connection has been regained, the self-repair process 500 can begin.

[0065] In operation 502, the node may generate a blockchain transaction indicating that it is “out of sync.” The “out of sync” blockchain transaction may be recorded in a distributed ledger to indicate to other nodes in the blockchain network that the self-healing node is not yet ready to contribute to model building iterations and / or act as a participant node. In some cases, the “out of sync” blockchain transaction is caused by a smart contract (e.g., Figure 3 502). In some cases, the "out of sync" blockchain transaction of operation 502 may be obtained by the master node as an indication that the self-repairing node may not have a model that is synchronized with the latest iteration of the ML. Therefore, in response to the "out of sync" blockchain transaction at operation 502, the master node may exclude the self-repairing node from participating in subsequent iterations of training the ML model. Excluding the master node causes the self-repairing node to effectively "wait" (e.g., wait for a complete iteration or epoch), thereby preventing any training parameters at the self-repairing node from being applied to the iterative model building.

[0066] In some cases, the self-repairing node may perform one or more preliminary actions prior to operation 502. For example, the self-repairing node may ensure that all services exposed as part of the initial setup process are operating properly. If the services are not operating properly, the self-repairing node is caused to automatically perform another restart. Additionally, the self-repairing node may ensure that all security attributes are correct and aligned with the data exposed during the initial setup process.

[0067] In operation 504, the self-repairing node may obtain a global ML state from the distributed ledger. Obtaining the global ML state may be performed as part of the synchronization aspect of self-repair, which determines whether the current local ML state is out of date relative to the rest of the participant nodes in the blockchain network. Interruptions may result in outdated or outdated learning data (e.g., training parameters) for the self-repairing node, which may degrade the overall state of the system if outdated learning data is introduced into the model building process. The self-repairing node knowing the global ML state allows the node to automatically synchronize its current state with the current state of the system subsequently. In some embodiments, the self-repairing node also obtains its local ML state from the distributed ledger. It is a feature of the blockchain that the distributed ledger maintains state data for all nodes on the blockchain network. Therefore, the data structure that maintains the local ML state of the self-repairing node will also be at the latest checkpoint and will also be in the distributed ledger. As needed, for example, if the self-repairing node loses all of its localized ML data, the local ML state may also be obtained from the distributed ledger in operation 504.

[0068] Additionally, operation 504 may include comparing the obtained global ML state to the local ML state to determine whether the local ML state is consistent with the global state. In the event that the comparison indicates that there is consistency between the local ML state and the global ML state, the self-healing node may continue normal operations. This may be due to the self-healing node restarting quickly enough so that updates to the ML data are not lost during the interruption. Therefore, in this scenario, the self-healing node maintains its synchronization with the system even in the event of a failure.

[0069] In operation 506, the self-repairing node uses one or more corrective actions to restore the local ML state at the node. The comparison at operation 504 may determine that the local ML state is inconsistent with the global ML state. Therefore, the self-repairing node may know that its current ML state is invalid or outdated relative to the latest model building iteration performed by another participant node on the blockchain network. As a result, the self-repairing node may automatically perform corrective actions to restore its local ML state to the point of the global ML state. Operation 506 may include performing multiple corrective actions, such as gradient sharing, parameter sharing, etc., and it should be understood that any method, process, or algorithm that allows the state of a peer node in the blockchain network to be used to restore the local ML state can be used. In the case of gradient sharing, the self-repairing node can obtain the latest ML checkpoint from at least one healthy peer and apply it to the local model update. Parameter sharing can be used in operation 506 as described above. Figure 4 Described method to perform.

[0070] In operation 508, the self-repairing node may ensure consistency of the local ML state with the global ML state following the corrective action of operation 506. In some cases, operation 508 may involve performing another comparison of the local ML state, now updated by the corrective action, with the global ML state.

[0071] In operation 510, the node may generate a blockchain transaction indicating that it is "syncing". The "syncing" blockchain transaction may be recorded in a distributed ledger and indicate to other nodes in the blockchain network (including the master node) that the self-healing node is synchronized with other nodes in the blockchain network and is ready to contribute to model building iterations and / or act as a participant node. Therefore, the self-healing node has successfully completed automatic synchronization and should be in a state consistent with the rest of the system. The node may use the "sync" blockchain transaction to identify that the self-healing node has been reintegrated into the system and can participate in the decentralized model building process.

[0072] In operation 512, the self-repairing node may re-register to be able to participate in the next model building iteration. In some embodiments, the self-repairing node is required to wait at least one complete iteration or period before acting as a participant node in the model building. The registration at operation 512 may be performed in a similar manner to the registration described above and is not discussed in detail for the sake of brevity.

[0073] Figure 6 1 depicts a block diagram of an example computer system 600 in which the self-repair embodiments described herein may be implemented. In addition, it should be appreciated that various instructions are illustrated as being co-located on a single processing unit (such as a node (e.g., Figure 1), but in implementations where the processor(s) include multiple processing units, one or more instructions may be executed remotely from other instructions.

[0074] Computer system 600 includes a bus 602 or other communication mechanism for communicating information, and one or more hardware processors 604 coupled with bus 602 for processing information. Hardware processor(s) 604 may be, for example, one or more general purpose microprocessors.

[0075] The computer system 600 also includes a main memory 606, such as a random access memory (RAM), cache, and / or other dynamic storage device, coupled to the bus 602 to store information and instructions to be executed by the processor 604. The main memory 606 may also be used to store temporary variables or other intermediate information during the execution of instructions to be executed by the processor 604. Such instructions, when stored in a storage medium accessible to the processor 604, transform the computer system 600 into a special-purpose machine customized to perform the operations specified in the instructions.

[0076] The computer system 600 further includes a read only memory (ROM) 608 or other static storage device coupled to the bus 602 for storing static information and instructions for the processor 604. A storage device 610, such as a magnetic disk, optical disk, or USB thumb drive (flash drive), etc., is provided and coupled to the bus 602 to store information and instructions.

[0077] The computer system 600 may be coupled to a display 612, such as a liquid crystal display (LCD) (or touch screen), via the bus 602 for displaying information to a computer user. An input device 614, including alphanumeric and other keys, is coupled to the bus 602 for communicating information and command selections to the processor 604. Another type of user input device is a cursor control 616, such as a mouse, trackball, or cursor direction keys, for communicating direction information and command selections to the processor 604 and controlling cursor movement on the display 612. In some embodiments, the same direction information and command selections as a cursor control may be achieved by receiving touches on a touch screen without a cursor.

[0078] The computing system 600 may include a user interface module for implementing a GUI, which may be stored in a mass storage device as executable software code executed by the computing device(s). This module and other modules may include, for example, components (such as software components, object-oriented software components, class components, and task components), processes, functions, properties, procedures, subroutines, program code segments, drivers, firmware, microcode, circuits, data, databases, data structures, tables, arrays, and variables.

[0079] In general, the terms "component", "engine", "system", "database", "data repository", etc., as used herein, may refer to logic embodied in hardware or firmware or a set of software instructions written in a programming language (such as, for example, Java, C or C++) that may have entry and exit points. Software components may be compiled and linked into an executable program, installed in a dynamic link library, or may be written in an interpreted programming language such as, for example, BASIC, Perl or Python. It will be understood that software components may be called from other components or from themselves, and / or may be called in response to detected events or interrupts. Software components configured to execute on a computing device may be provided on a computer-readable medium (such as a compact disc, digital video disc, flash drive, disk, or any other tangible medium), or provided in the form of a digital download (and may be initially stored in a compressed format or installable format that requires installation, decompression or decryption prior to execution). Such software code may be stored in part or in whole on a memory device of an executing computing device for execution by the computing device. Software instructions may be embedded in firmware such as an EPROM. It will also be understood that hardware components may include connected logic units, such as gates and flip-flops, and / or may include programmable units, such as programmable gate arrays or processors.

[0080] The computer system 600 may implement the techniques described herein using custom hardwired logic, one or more ASICs or FPGAs, firmware and / or program logic that is combined with the computer system to make the computer system 600 a special purpose machine or program the computer system 600 to be a special purpose machine. According to one embodiment, the techniques herein are performed by the computer system 600 in response to the processor(s) 604 executing one or more sequences of one or more instructions contained in the main memory 606. Such instructions may be read into the main memory 606 from another storage medium such as the storage device 610. Executing the sequences of instructions contained in the main memory 606 causes the processor(s) 604 to perform the process steps described herein. In alternative embodiments, hardwired circuitry may be used in place of or in combination with software instructions.

[0081] As used herein, the term "non-transitory medium" and similar terms refer to any medium that stores data and / or instructions that cause a machine to operate in a particular manner. Such non-transitory media may include non-volatile media and / or volatile media. Non-volatile media include, for example, optical or magnetic disks, such as storage device 610. Volatile media include dynamic memory, such as main memory 606. Common forms of non-transitory media include, for example, floppy disks, flexible disks, hard disks, solid-state drives, tapes or any other magnetic data storage media, CD-ROMs, any other optical data storage media, any physical media with a pattern of holes, RAM, PROMs and EPROMs, FLASH-EPROMs, NVRAMs, any other memory chips or cassettes, and networked versions thereof.

[0082] Non-transient media are distinct from transmission media but can be used in conjunction with transmission media. Transmission media participate in the transfer of information between non-transient media. For example, transmission media include coaxial cables, copper wires, and optical fibers, including the wires that make up bus 602. Transmission media can also take the form of acoustic or light waves, such as those generated during radio wave and infrared data communications.

[0083] Computer system 600 also includes a communication interface 618 coupled to bus 602. Network interface 618 provides bidirectional data communication coupled to one or more network links connected to one or more local networks. For example, communication interface 618 can be an integrated services digital network (ISDN) card, a cable modem, a satellite modem, or a modem for providing a data communication connection to a corresponding type of telephone line. As another example, network interface 618 can be a local area network (LAM) card for providing a data communication connection with a compatible LAM (or a WAN component communicating with a WAN). A wireless link can also be implemented. In any such implementation, network interface 618 sends and receives electrical signals, electromagnetic signals, or optical signals carrying digital data streams representing various types of information.

[0084] A network link typically provides data communication to other data devices via one or more networks. For example, a network link may provide a connection to a host computer or data device operated by an Internet Service Provider (ISP) via a local network. The ISP, in turn, provides data communication services via a global packet data communication network now commonly referred to as the "Internet." Both the local network and the Internet use electrical, electromagnetic, or optical signals that carry digital data streams. The signals via the various networks and the signals on the network link and via the communication interface 618 are example forms of transmission media that carry digital data to and from the computer system 600.

[0085] Computer system 600 can send messages and receive data, including program code, via network(s), network links, and communication interface 618. In the example of the Internet, a server can transmit the code requested by an application via the Internet, an ISP, a local network, and communication interface 618.

[0086] The received code may be executed by processor 604 as it is received, and / or stored in storage device 610 or other non-volatile storage for later execution.

[0087] Each process, method, and algorithm described in the preceding sections may be embodied in a code component executed by one or more computer systems or a computer processor including computer hardware, and may be fully or partially automated by the code component. One or more computer systems or computer processors may also operate to support the performance of related operations in a "cloud computing" environment or as "software as a service" (SaaS). The process and algorithm may be implemented in part or in whole in a dedicated circuit. The various features and processes described above may be used independently of each other, or may be combined in various ways. Different combinations and sub-combinations are intended to fall within the scope of the present disclosure, and certain method or process blocks may be omitted in certain implementations. The methods and processes described herein are also not limited to any particular order, and the blocks or states associated therewith may be executed in other appropriate orders, or may be executed in parallel, or in some other manner. Frames or states may be added to or deleted from the disclosed example embodiments. The execution of certain operations or processes may be distributed between computer systems or computer processors, not only residing in a single computer, but also deployed across multiple computers.

[0088] As used herein, circuits can be implemented using any form of hardware, software, or a combination thereof. For example, one or more processors, controllers, ASICs, PLAs, PALs, CPLDs, FPGAs, logic components, software routines, or other mechanisms can be implemented to form circuits. In implementations, the various circuits described herein can be implemented as discrete circuits, or the functions and features described can be shared in part or in whole between one or more circuits. Even if various functional features or elements can be described or claimed as separate circuits separately, these features and functions can also be shared between one or more general-purpose circuits, and such descriptions will not require or imply the need for separate circuits to implement such features or functions. In the case where the circuit is implemented in whole or in part using software, such software can be implemented to operate together with a computing or processing system (such as computer system 600) that can perform the functions described relative to this.

[0089] As used herein, the term "or" may be interpreted in an inclusive or exclusive sense. Furthermore, descriptions of resources, operations, or structures in the singular should not be understood to exclude the plural. Unless otherwise expressly stated or otherwise understood in the context of use, conditional language (such as "may", "can / could / might / may", etc.) is generally intended to convey that certain embodiments include, while other embodiments do not include, certain features, elements, and / or steps.

[0090] Unless expressly stated otherwise, the terms and phrases used in this document and variations thereof should be interpreted as open-ended, not restrictive. Adjectives such as "conventional," "traditional," "nominal," "standard," "known," and terms of similar meaning should not be interpreted as limiting the items described to items available in a given time period or in a given time period, but should be understood to cover conventional, traditional, nominal, or standard technologies available or known now or in the future. In some cases, the presence of broad words and phrases such as "one or more," "at least," "but not limited to," or other similar phrases should not be understood to mean that narrower cases are intended or required in the absence of these broad words and phrases.

Claims

1. A decentralized machine learning (ML) system, comprising: A self-healing computer node of a blockchain network, the blockchain network comprising a plurality of computing nodes, the self-healing computer node recovering from a fault condition within the blockchain network and being programmed to: generating a first blockchain transaction, the first blockchain transaction including an indication that the self-healing computer node is out of sync with a most recent iteration of training the machine learning model, wherein the first blockchain transaction is to be added to a distributed ledger and notifies the plurality of computing nodes that the self-healing computer node is not ready to participate in a subsequent iteration of training the machine learning model; Obtaining a global ML state from the distributed ledger; comparing the obtained global ML state with a local ML state at the self-healing computer node to determine whether the local ML state is consistent with the global ML state; When determining that the local ML state is inconsistent with the global ML state, triggering a corrective action using the blockchain network to restore the local ML state to be consistent with the global ML state; generating a second blockchain transaction, the second blockchain transaction including an indication that the self-healing computer node is synchronized with the most recent iteration of training the machine learning model, wherein the second blockchain transaction is to be added to the distributed ledger and informs the plurality of computing nodes that the self-healing computer node is ready to participate in a subsequent iteration of training the machine learning model; as well as Re-registering with the blockchain network to participate in the subsequent iteration of training the machine learning model.

2. The system according to claim 1, further comprising: a participant node from the plurality of computing nodes on the blockchain network, wherein the participant node is registered to participate in training the most recent iteration of the machine learning model; as well as A master node selected from among the participant nodes in the most recent iteration of training the machine learning model.

3. The system of claim 2, wherein the master node is programmed to: receiving an indication that the self-healing computer node is out of sync with a most recent iteration of training the machine learning model; and Based on the indication that the self-repairing computer node is out of sync, excluding the self-repairing computer node from participating in subsequent iterations of training the machine learning model such that training parameters associated with the local ML state of the self-repairing computer node are avoided from being applied to the machine learning model.

4. The system of claim 3, wherein excluding the self-healing computer node from participating in subsequent iterations of training the machine learning model enables the machine learning model to be trained to tolerate the failure condition within the blockchain network.

5. The system of claim 2, wherein the master node is programmed to: receiving the indication that the self-repairing computer node is synchronized with a latest iteration of training the machine learning model; and Based on the indication of synchronization of the self-repairing computer node, including the self-repairing computer node to participate in the subsequent iteration of training the machine learning model such that training parameters associated with the local ML state of the self-repairing computer node are applied to the machine learning model.

6. The system of claim 5, wherein including the self-healing computer node to participate in the subsequent iterations of training the machine learning model reintegrates the self-healing computer node into decentralized machine learning.

7. The system of claim 2, wherein the self-repairing computer node is further programmed to: Based on the triggering of the corrective action, obtaining shared training parameters generated by a participant node on the blockchain network, wherein the shared training parameters are based on a local model of the participant node trained during the most recent iteration; and The training parameters are applied to update the local ML state at the self-repairing computer node.

8. The system of claim 2, wherein the master node is further programmed to: obtaining shared training parameters from the participant nodes on the blockchain network, wherein the shared training parameters are based on local models of the participant nodes trained during the most recent iteration; generating a merged training parameter based on the shared training parameter; generating a transaction including an indication that the master node has generated the merged training parameters; The transaction is caused to be written as a block on the distributed ledger.

9. The system of claim 8, wherein the self-repairing computer node is further programmed to: Based on the triggering of the corrective action, obtaining the merged training parameter from the master node; The merged training parameters are applied to update the local ML state at the self-repairing computer node.

10. The system of claim 1, wherein the fault condition within the blockchain network is a network connection interruption, a power outage, or a computing node crash.

11. The system of claim 9, wherein the self-repairing computer node is further programmed to: A node restart is automatically performed to recover from the fault condition.

12. A method for self-repairing a computing node of a blockchain network comprising a plurality of computing nodes, wherein the self-repairing computer node recovers from a fault condition within the blockchain network, the method comprising: automatically generating, by the self-healing computer node, a first blockchain transaction including an indication that the self-healing computer node is out of sync with a most recent iteration of training a machine learning model, wherein the first blockchain transaction is to be added to a distributed ledger and informs the plurality of computing nodes that the self-healing computer node is not yet ready to participate in a subsequent iteration of training the machine learning model; obtaining, by the self-healing computer node, a global ML state from the distributed ledger; comparing, by the self-repairing computer node, the obtained global ML state with a local ML state at the self-repairing computer node to determine whether the local ML state is consistent with the global ML state; When it is determined that the local ML state is inconsistent with the global ML state, the computing node automatically triggers a corrective action using the blockchain network to restore the local ML state to be consistent with the global ML state; as well as automatically generating, by the self-healing computer node, a second blockchain transaction including an indication that the self-healing computer node is synchronized with the most recent iteration of training the machine learning model, wherein the second blockchain transaction is to be added to the distributed ledger and informs the plurality of computing nodes that the self-healing computer node is ready to participate in a subsequent iteration of training the machine learning model; as well as Re-registering with the blockchain network by the self-healing computer node to participate in the subsequent iteration of training the machine learning model.

13. The method according to claim 12, comprising: receiving, by a master node, an indication that the self-healing computer node is out of sync with the most recent iteration of training the machine learning model; as well as Excluding, by the master node, the self-repairing computer node from participating in the subsequent iteration of training the machine learning model based on the indication that the self-repairing computer node is out of sync, such that training parameters associated with the local ML state of the self-repairing computer node are avoided from being applied to the machine learning model.

14. The method of claim 13, wherein excluding the self-healing computer node from participating in the subsequent iterations of training the machine learning model enables the machine learning model to be trained to tolerate the failure condition within the blockchain network.

15. The method according to claim 13, comprising: receiving, by the master node, the indication that the self-healing computer node is synchronized with a latest iteration of training the machine learning model; as well as The indication, by the master node based on synchronization by the self-repairing computer node, includes the self-repairing computer node in participating in the subsequent iteration of training the machine learning model such that training parameters associated with the local ML state of the self-repairing computer node are applied to the machine learning model.

16. The method of claim 15, wherein including the self-healing computer node to participate in the subsequent iteration of training the machine learning model reintegrates the self-healing computer node into decentralized machine learning.

17. The method according to claim 12, comprising: based on the triggering of the corrective action, obtaining, by the self-healing computer node, shared training parameters generated by participant nodes on the blockchain network, wherein the shared training parameters are based on local models of the participant nodes trained during the most recent iteration; as well as The training parameters are applied by the self-repairing computer node to update the local ML state at the self-repairing computer node.

18. The method according to claim 13, comprising: Based on the triggering of the corrective action, obtaining, at the self-healing computer node, a merged training parameter generated by the master node, wherein the merged training parameter is based on merging a plurality of shared parameters from participant nodes on the blockchain network and generated during the most recent iteration; as well as The merged training parameters are applied by the self-repairing computer node to update the local ML state at the self-repairing computer node.

19. The method according to claim 12, comprising: A node restart is automatically performed by the self-healing computer node to recover from the fault condition.

20. A non-transitory machine-readable storage medium comprising instructions executable by a processor of a self-healing computer node of a blockchain network, the blockchain network comprising a plurality of computing nodes, the self-healing computer node recovering from a fault condition within the blockchain network, the instructions programming the processor to: generating a first blockchain transaction, the first blockchain transaction including an indication that the self-healing computer node is out of sync with a most recent iteration of training the machine learning model, wherein the first blockchain transaction is to be added to a distributed ledger and notifies the plurality of computing nodes that the self-healing computer node is not ready to participate in a subsequent iteration of training the machine learning model; Obtaining a global ML state from the distributed ledger; comparing the obtained global ML state with a local ML state at the self-healing computer node to determine whether the local ML state is consistent with the global ML state; When determining that the local ML state is inconsistent with the global ML state, triggering a corrective action using the blockchain network to restore the local ML state to be consistent with the global ML state; as well as generating a second blockchain transaction, the second blockchain transaction including an indication that the self-healing computer node is synchronized with the most recent iteration of training the machine learning model, wherein the second blockchain transaction is to be added to the distributed ledger and notifies the plurality of computing nodes that the self-healing computer node is ready to participate in a subsequent iteration of training the machine learning model; as well as Re-registering with the blockchain network to participate in the subsequent iteration of training the machine learning model.