Replica processing unit for Boltzmann machine

Abstract

To provide replica processing units that may be used with Boltzmann Machines.SOLUTION: Operations may include performing, based on weights and local field values associated with an optimization problem, a stochastic process with respect to changing a respective state of one or more variables that each represent a characteristic related to the optimization problem. The stochastic process may include performing trials with respect to one or more of the variables, in which a respective trial determines whether to change a respective state of a respective variable. The operations additionally may include determining an acceptance rate of state changes of the variables during the stochastic process and adjusting a degree of parallelism with respect to performing the trials based on the determined acceptance rate.SELECTED DRAWING: Figure 1

Description

[Technical Field]

[0001] The embodiments discussed herein relate to replica processing units that may be used in a Boltzmann machine. [Background technology]

[0002] Combinatorial optimization problems are often classified as NP problems (nondeterministic polynomial-time problems), such as NP-hard or NP-complete problems, and often there are no known algorithms for solving such problems in polynomial time. Such combinatorial optimization problems can appear in many applications, such as minimizing the number of vias in layout design, maximizing returns from stock portfolios, airline routing and scheduling, and wireless sensor networks.

[0003] The subject matter claimed herein is not limited to embodiments that resolve any shortcomings or operate only in the environments described above. Rather, this background art is provided solely to illustrate one exemplary technical field in which some embodiments described herein may be carried out. [Overview of the Initiative]

[0004] In one embodiment, the operation may include obtaining a state matrix of a system representing an optimization problem, the state matrix containing variables, each representing a feature related to the optimization problem. The operation may further include obtaining weights corresponding to the variables, each weight relating to one or more relationships between each variable in the state matrix and one or more other variables. Furthermore, the operation may further include obtaining a local field matrix containing local field values, the local field values ​​representing interactions between variables influenced by each weight of each variable. Furthermore, the operation may include performing a stochastic process with respect to changing the respective states of one or more of the variables based on the weights and local field values. The stochastic process may include performing trials with respect to one or more of the variables, each trial determining whether to change the respective state of each variable. The operation may further include determining an acceptance rate for state changes of the variables during the stochastic process and adjusting the degree of parallelism with respect to performing trials based on the determined acceptance rate.

[0005] The objectives and advantages of the embodiments are realized and achieved by at least the elements, features, and combinations specifically indicated in the claims.

[0006] Both the general description above and the detailed description below are given as examples and are illustrative, not limiting to the claimed invention. [Brief explanation of the drawing]

[0007] Exemplary embodiments are described and illustrated with further specificity and detail through the use of the accompanying drawings. [Figure 1] This diagram represents an exemplary environment configured to solve an optimization problem. [Figure 2A] An exemplary replica exchange unit (RPU) configured to perform operations related to solving an optimization problem is shown. [Figure 2B]An exemplary merged RPU is shown. [Figure 2C] Another exemplary merged RPU is shown. [Figure 2D] Another exemplary merged RPU is shown. [Figure 2E] An exemplary system configured to execute a replica exchange process using multiple RPUs is shown. [Figure 3] A block diagram of an exemplary computing system configured to execute a replica exchange process is shown. [Figure 4] A flowchart of an exemplary method of performing trials during the solution of an optimization problem is shown.

Best Mode for Carrying Out the Invention

[0008] The combinatorial optimization problem may include a class of optimization problems that can be used to determine the maximum or minimum value of an energy or cost function of a system. For example, combinatorial optimization can be used to minimize the number of vias in circuit layout design, maximize stock returns, improve airline routing and scheduling, and configure wireless sensor networks, among other applications.

[0009] In some embodiments, the system may be used to represent or solve an optimization problem. For example, the system may include a neural network that represents an optimization problem. In these or other embodiments, the neural network may include any appropriate number of nodes (also called “neurons”). In these or other embodiments, each neuron may correspond to a feature of the optimization problem. Furthermore or alternatively, the state of each neuron in the neural network may be used to represent the state of a different feature of the optimization problem. Thus, the collective state of neurons may be used to represent the overall state of the optimization problem. In these or other embodiments, the neural network may be configured to represent and / or solve one or more different types of optimization problems in any appropriate way. In some embodiments, the neural network may be configured as a Boltzmann machine.

[0010] Furthermore, the overall state space of a system (e.g., a Boltzmann machine) can be represented as Ising energy ("energy"). In these or other embodiments, the solution to the optimization problem may be determined using a minimization or maximization method. A minimization method can be used to determine the minimum energy of the system, and a maximization method can be used to determine the maximum energy of the system. For example, the state of the system corresponding to the determined minimum or maximum energy may be used as the solution to a particular optimization problem. In these or other embodiments, a stochastic process may be used to randomly select neurons and change the state of the neurons to determine the maximum or minimum energy.

[0011] References in this disclosure to determining minimum or maximum energy are not limited to determining the absolute minimum or absolute maximum energy of a system. Instead, references to determining minimum or maximum energy may include performing a minimize or maximize operation with respect to the energy of the system, the output of which is used as the solution to the corresponding optimization problem.

[0012] Furthermore, or alternatively, a Markov Chain Monte Carlo (MCMC) process may be performed on the system as part of solving the corresponding optimization problem. For example, replica exchange may be performed to find the minimum or maximum energy of the system. Replica exchange involves running M copies of the system simultaneously, but may include using different scaling factors that affect whether changes occur to the system between the running copies.

[0013] As detailed below, according to one or more embodiments of the present disclosure, the system may include one or more replica processing units ("RPUs"), each of which may be configured to run one or more replicas of a system (e.g., a Boltzmann machine). The RPUs may be configured to run different types of Boltzmann machines. For example, as will be discussed and described in more detail below, the RPUs may be configured to handle different modes of operation. For example, the RPUs may be configured to run regular Boltzmann machines and / or clustered Boltzmann machines, such as row-clustered Boltzmann machines, column-clustered Boltzmann machines, or cross-clustered Boltzmann machines.

[0014] In these or other embodiments, multiple RPUs may be implemented together so that each runs one or more different replicas of the system, thereby configuring the RPUs to perform a replica exchange process. Furthermore, or alternatively, two or more of the different RPUs participating in the replica exchange process may run in different operating modes, which may increase the versatility used to solve the optimization problem.

[0015] Furthermore, or alternatively, the RPU may be configured to operate at different levels of parallelism during the resolution of the optimization problem. In these or other embodiments, the amount of parallelism may be adjusted based on the acceptance rate of state changes of the system's variables during the solution. Furthermore, or alternatively, an offset that may affect the acceptance rate may be adjusted during the solution.

[0016] Adjusting parallelism and / or offset can help improve the speed and / or efficiency of an RPU. For example, increasing offset and / or parallelism can increase the speed at which an RPU, or a computing system containing one or more RPUs, can solve a problem. Further adjusting parallelism can improve the ability of the RPU and / or associated computing system to solve problems by drawing solutions from local minimums or local maximums. Additionally, reducing parallelism when it may not be very beneficial can reduce the amount of computational resources that can be used by the RPU, which can improve the efficiency of the RPU and / or associated computing system while solving problems.

[0017] Embodiments of this disclosure will be described with reference to the accompanying drawings.

[0018] Figure 1 is a diagram representing an exemplary environment 100 configured to solve an optimization problem, arranged according to at least one embodiment described herein. The environment 100 may include an energy determination engine 102 ("energy engine 102") configured to update and output a system update 104 of system 106. In these or other embodiments, the environment 100 may include a local field matrix engine 108 ("LFM engine 108") configured to update a local field matrix 110 ("LFM 110") based on the system update 104. In some embodiments, one or more replica processing units may be configured to realize the environment 100, as will be discussed in more detail below.

[0019] Corollary 106 can include any suitable representation of the optimization problem that can be solved. For example, in some embodiments, Corollary 106 may include a state matrix X which may include a set of variables, each representing a feature related to the optimization problem. Thus, the state matrix X can represent different states of Corollary 106. For example, a first state matrix X1, where each variable has a first value, may represent a first state of Corollary 106, and a second state matrix X2, where the variables have second values, may represent a second state of Corollary 106. In these or other embodiments, the difference between state matrices X1 and X2 may range from having only one corresponding variable in both X1 and X2 having a different value to having all variables in X1 and X2 having different values. In some embodiments, the state matrix X is a state vector X v It may also be represented by:

[0020] In these or other embodiments, the environment 100 may include a weight matrix 112. The weight matrix 112 may represent connection weights that may correspond to the variables of system 106. In some embodiments, each connection weight may relate to one or more relationships between each variable of system 106 and one or more other variables.

[0021] In these or other embodiments, the environment 100 may include a local field matrix 110 ("LFM110"). The LFM110 may be used to indicate the change in the energy of a particular system when the state of a variable in that system changes (for example, when the state of a variable included in the state vector X changes). The LFM110 may include values ​​based on the interactions between the variables of a particular system, which are influenced by their respective weights with respect to the change in the state of one or more of the variables.

[0022] In some embodiments, system 106 may be a neural network that may contain any appropriate number of nodes (also called “neurons”). In these or other embodiments, the state matrix X of system 106 may represent the state of each neuron in the neural network. For example, each neuron may be a bit that can have a value of “0” or “1”, and the state matrix X may contain a value of “1” or “0” for each neuron in the neural network. In these or other embodiments, the neural network may be configured to solve one or more different types of optimization problems in any appropriate way.

[0023] In some embodiments, the neural network of System 106 may be configured as a Boltzmann machine. In these or other embodiments, the Boltzmann machine may be configured as a clustered Boltzmann machine (CBM), in which the neurons of the Boltzmann machine can be grouped into clusters. Clusters may be formed such that no connections exist between neurons within the same cluster (e.g., the connection weights between neurons in a cluster may be "0"). In these or other embodiments, the CBM may be configured to have at most n constraints, where only "n" neurons in any given cluster can be active (e.g., have a bit value of "1"). For example, the CBM may have an exactly-1 constraint (also called "1-hot encoding"), whereby exactly one of the neurons in a cluster is always active (e.g., has a bit value of "1") and the rest of the neurons in the cluster must be inactive (e.g., have a bit value of "0"). Examples of clustering that can be used are row clustering and / or column clustering with respect to the rows and columns of a state matrix X. In these or other embodiments, clusters may be combined to form cross clusters. For example, row clusters can be combined with column clusters to form cross clusters. Such a cross cluster configuration with the constraint exactly 1 can restrict the state matrix X such that only one neuron can be active in each row and each column of the state matrix X.

[0024] In some embodiments, the state matrix X can be reduced in size using clustering. For example, in a given cluster (e.g., a particular row) with the constraint of exactly 1, only one neuron can be active, and therefore, instead of storing a value that indicates the state of all neurons in the cluster, a single index value that indicates which neuron in the cluster is active may be stored. In such an example, the state matrix X may be represented by a state vector X.

[0025] Furthermore, or alternatively, system 106 may include an Ising model mapped to the optimization problem in order to represent the Ising energy of the optimization problem corresponding to system 106. For example, the Ising energy of a system in which the variables are in binary states can be expressed by equation (1) below.

number

[0026] The energy engine 102 may include code and routines configured to enable a computing system to perform one or more of the operations described therein. Furthermore, or alternatively, the energy engine 102 may be implemented using hardware including any number of processors, microprocessors (for example, to perform or control one or more operations), field-programmable gate arrays (FPGAs), application-specific integrated circuits (ASICs), or any suitable combination of two or more of these.

[0027] Furthermore, or alternatively, the energy engine 102 may be implemented using a combination of hardware and software. In this disclosure, operations described as being performed by the engine 102 may include operations that the energy engine 102 may instruct the corresponding system to perform.

[0028] In some embodiments, the energy engine 102 may be configured to randomly (e.g., via a stochastic process) generate proposed changes for one or more variables of the state matrix X. For example, in some embodiments, in a CBM with an exact 1 constraint, the proposed changes may include changing an inactive neuron (e.g., represented by a state variable in the state matrix X) to active, and consequently changing an active neuron to inactive. Thus, with respect to any given cluster, two changes (e.g., a bit flip) may occur. Furthermore, or alternatively, in a cross-cluster configuration with an exact 1 constraint, such as a combinational row cluster and a combinational column cluster configuration, the proposed changes may include a 4-bit flip because changing the state of a neuron in a particular row also affects the column to which the changed neuron belongs.

[0029] In some embodiments, the decision of whether to accept a particular change for a particular cluster can be based on any suitable probability function. In these or other embodiments, the probability function may be based on the change in system energy that may be caused by the particular change. In some embodiments, the change in system energy may be determined using LFM110.

[0030] As described above, LFM110 can demonstrate the interactions between the variables of system 106, which are influenced by their respective weights with respect to changes in the state of the variables. For example, the values ​​of the variables in system 106 of LFM110 can be expressed in equation (2) as follows:

number

[0031] In Equation (2), h i (x) is the local field value of the i-th variable of the local field matrix H, and the i-th variable of the local field matrix H corresponds to the i-th variable of the corresponding state matrix X, and x j is a variable of the state vector X and can be either 0 or 1, and w ij is the connection weight between the i-th and j-th variables of X, and b i is the bias associated with i.

[0032] As described above, in some embodiments, the change in the system energy with respect to the modification can be based on the LFM 110. For example, the change in the system energy of the non-cross-clustered CBM (e.g., of the row clusters of the CBM) can be determined as follows in Equation (3). [Number]

[0033] In Equation (3), k represents a given row of the state matrix X indexed by the corresponding state vector X RC , h k,j and h k,i correspond to the neurons involved in the modification. In Equation (3), h k,j is the local field matrix value corresponding to the neuron x k,j , and h k,i is the local field matrix value corresponding to the neuron x k,i . Before the swap proposal that would activate x k,j and deactivate x k,i , the neuron x k,j is inactive and the neuron x k,i is active.

[0034] As another example, the change in the system energy of the cross-clustered CBM (e.g., row / column cross-clustered CBM) can be determined as follows in Equation (4).

number

[0035] In equation (4), k and k' are the corresponding state vector X XC The rows of the state matrix X indexed by l and l' represent the state vector X. XC This represents the index of the active neurons in rows k and k', respectively, and h k,l h k',l' h k,l' , and h k',l As mentioned above, this corresponds to the neurons involved in the proposed changes, w k,l:k',l' and w k,l':k',l This corresponds to a weight that can correspond to the neuron that is in question regarding the proposed change.

[0036] In some embodiments, the weight matrix 112 may include weight values ​​or a subset of weight values, thereby allowing the energy engine 102 to obtain weights by deriving the corresponding values ​​from the weight matrix 112. Furthermore, or alternatively, the weight matrix 112 may include a first matrix and a second matrix that can be used by the energy engine 102 to determine weight values, as described in U.S. Patent Application No. 16 / 849,887, filed on April 15, 2020, which is incorporated in its entirety by reference herein.

[0037] As described above, the probability of accepting or being able to accept a proposed change for one or more variables can be based on the change in system energy that may occur in response to the proposed change. For example, the probability of acceptance of a proposed change in a system of non-cross-clustered CBMs (e.g., row clusters of CBMs) where the change in energy is determined based on equation (3) above can be determined by equation (5) as follows:

number

[0038] In equation (5), ΔE RC (XRC k) may be an energy change determined from equation (3), and t may be a scaling factor that can be used to influence whether or not the change occurs. For example, t may be a “temperature” used as a scaling factor when performing simulated or digital annealing processes such as replica exchange (also known as “parallel tempering”).

[0039] As another example, the acceptance probability of a proposed change in a system of cross-clustered CBMs (e.g., row / column cross-clusters of CBMs) where the energy change is determined based on equation (4) above can be determined by equation (6) as follows:

number

[0040] In equation (6), ΔE RC (X XC k, k') may be the energy change determined from equation (4), and t may be the scaling factor described above with respect to equation (5).

[0041] Energy engine 102 can output system update 104. System update 104 may include updates to system 106 that may occur in response to accepting one or more proposed changes.

[0042] In some embodiments, the energy engine 102 may be included in or part of an annealing system (e.g., a digital annealing system or a quantum annealing system). In these or other embodiments, the energy engine 102 may be configured to perform a replica-exchange Markov chain Monte Carlo (MCMC) process with respect to system 106. For example, the energy engine 102 may be configured to perform a replica exchange to find a state vector Xmin that can minimize the energy of system 106. As another example, the energy engine 102 may be configured to perform a replica exchange to find a state vector Xmax that can maximize the energy of system 106. As described above, the replica exchange may involve performing M copies of system 106 simultaneously, but may include using different scaling factors that affect whether changes occur to the system between the executions of the copies of system 106. Thus, in some embodiments, the energy engine 102 can perform the above-described update operations at different temperature levels with respect to multiple replicas of system 106.

[0043] The LFM engine 108 may be configured to update LFM 110 based on updates to system 106 that may be reflected in system update 104. Alternatively, the LFM engine 108 may be configured to initially generate LFM 110 based on system 106 during the initialization of the solution to the corresponding optimization problem.

[0044] Figure 1 may be modified, added to, or omitted without departing from the scope of this disclosure. For example, the specific configuration of system 106 may vary depending on different implementations. Furthermore, the operations described as being performed by the energy engine 102 and / or LFM engine 108 may be performed by any applicable implementation, which may not be exactly the same as those described herein. Furthermore, environment 100 may include more or fewer elements than those illustrated and described herein. Furthermore, the specific configuration, association, or inclusion of elements in a particular device or system may vary depending on the specific implementation. For example, system 100 and / or the operations described therein may be performed using one or more RPUs, which will be discussed in more detail below.

[0045] Figure 2A is a diagram representing an exemplary replica processing unit 200 ("RPU200") configured to perform operations related to solving an optimization problem, arranged according to at least one embodiment described herein. The RPU200 may include a state block 202, a local field block 204, a weight block 206, an arithmetic element 208, and a decision element 210.

[0046] The state block 202 may include any suitable computer-readable storage medium that may store a state matrix X that can represent a particular optimization problem. The state matrix X may be similar to the state matrix X discussed above with respect to Figure 1. Furthermore, in some embodiments, the state block 202 may be sized to store a square matrix having D rows and D columns. Thus, in some embodiments, the state block 202 may store a single state matrix X sized as a D×D matrix. Furthermore or alternatively, in examples where the state matrix X has fewer values ​​than a D×D matrix, the state matrix X may be stored in rows of size D or columns of size D. In these or other embodiments, depending on the nature of the optimization problem and the subsequent size of the corresponding state matrix X, in some embodiments, the state block 202 may store two or more state matrices X.

[0047] The local field block 204 may include any suitable computer-readable storage medium that may store a local field matrix H for a particular optimization problem. The local field matrix H may be similar to the local field matrix 110 discussed above with respect to Figure 1. Furthermore, in some embodiments, the local field block 204 may be sized to store a square matrix having D rows and D columns. Thus, in some embodiments, the local field block 204 may store a single local field matrix H sized as a D×D matrix. Furthermore or alternatively, in examples where the local field matrix H has fewer values ​​than a D×D matrix, the local field matrix H may be stored in rows of size D or columns of size D. In these or other embodiments, depending on the nature of the optimization problem and the subsequent size of the corresponding local field matrix H, in some embodiments, the local field block may store two or more local field matrices H.

[0048] The weight block 206 may include any suitable computer-readable storage medium that may store the weight matrix W of a particular optimization problem. The weight matrix W may be similar to the weight matrix 112 discussed above with respect to Figure 1. In some embodiments, the weight matrix W stored in the weight block 206 may be the entire N×N weight matrix. Furthermore or alternatively, the weight matrix W stored in the weight block 206 may be a subset of the complete weight matrix corresponding to a particular optimization problem. In these or other embodiments, the weight block 206 can operate as a cache for storing a subset of the complete weight matrix. Furthermore or alternatively, in an example where the weight block 206 operates as a cache, the complete weight matrix W may be stored in a computer-readable storage medium outside the chip on which the RPU 200 may be built. Furthermore or alternatively, in some embodiments (e.g., an example where the RPU implements a cross-clustered Boltzmann machine), the weight block 206 may include a first matrix and a second matrix that may be used to determine the weight values, as described in U.S. Patent Application No. 16 / 849,887.

[0049] The arithmetic element 208 may include any suitable hardware and / or software configured to perform arithmetic operations that can be used to solve optimization problems. For example, the arithmetic element 208 may include one or more adders configured to perform addition and subtraction, and / or one or more multipliers configured to perform multiplication and division. Furthermore or alternatively, the adders and multipliers may, in some embodiments, be configured to perform fused multiply-addition. In these or other embodiments, the adders and / or multipliers of the arithmetic element 208 can be configured so that the arithmetic element 208 may be able to perform up to D arithmetic operations in parallel. Thus, the arithmetic element 208 can be configured to perform in parallel arithmetic operations that potentially modify the state of each state variable contained in a row or column of the state matrix X, as will be discussed in more detail below. For example, as will be discussed in more detail below, the arithmetic element 208 may be configured to perform arithmetic operations relating to determining each energy change that can be caused by changing the state of each variable in the state matrix X, in which case the determined energy change may be used to determine whether to change the state of each variable.

[0050] The decision element 210 (indicated as "F" in Figure 2A) may include any suitable hardware and / or software configured to perform operations related to deciding whether to accept or reject a state change proposal for each variable of the state matrix X. For example, the decision element 210 may include one or more comparators, each configured to perform a Bernoulli trial for each value received from the arithmetic element 208. The Bernoulli trial can determine whether to accept or reject a state change for each state variable based on the received value (for example, based on the corresponding determined energy change). In some embodiments, the decision element 210 may include D comparators arranged in parallel, thereby configuring the decision element 210 to make D decisions in parallel.

[0051] In these or other embodiments, the decision element 210 may include a D-to-1 tournament reduction tree that can be configured to randomly select one of the acceptable state changes from a maximum of DIM candidates for acceptable state changes. In these or other embodiments, the selected accepted state change for the corresponding state variable may be used to update the values ​​of the state matrix X, local field matrix H, and weight matrix W corresponding to the corresponding state variable with the accepted state change.

[0052] In some embodiments, the RPU 200 may be communicated to a system controller 284 ("Controller 284"). The Controller 284 may include code and routines configured to enable the computing system to perform one or more of the operations described herein. Furthermore or alternatively, the Controller 284 may be implemented using hardware including any number of processors, microprocessors (e.g., for performing or controlling one or more operations), field-programmable gate arrays (FPGAs), application-specific integrated circuits (ASICs), or any suitable combination of two or more of these. Alternatively or further, the Controller 284 may be implemented using a combination of hardware and software. Operations described in this disclosure as being performed by the Controller 284 may include operations that the Controller 284 may instruct the corresponding system to perform.

[0053] The controller 284 may be configured to instruct the RPU 200 to perform one or more control operations. For example, the controller 284 may be configured to instruct the loading of data from one or more applicable external sources into different blocks of the RPU 200. For example, the controller 284 may be configured to update the weight matrix W with values ​​stored in external memory, in an example where the weight block 206 is used as a cache. Furthermore or alternatively, the controller 284 may be configured to load the state matrix X and / or local field matrix H into the state block 202 and local field block 204, respectively, as part of the initialization of the RPU 200 for a particular optimization problem. In these or other embodiments, the controller 284 may be configured to instruct the RPU 200 regarding the type of system it can implement. For example, the controller 284 can instruct the RPU 200 to operate as a normal Boltzmann machine, a row-clustered Boltzmann machine, and / or a cross-clustered Boltzmann machine.

[0054] As described above, the arithmetic element 208 and the decision element 210 may be configured to perform a stochastic process with respect to changing the state of each of one or more of the variables in the state matrix X. The stochastic process may include performing each trial for each of one or more of the variables to determine whether to change the state of each of the variables. In some embodiments, the stochastic process may be directed by the controller 284.

[0055] For example, in some embodiments, the arithmetic element 208 may be configured to retrieve corresponding values ​​from a local field matrix H, a weight matrix W, and a state matrix X. For example, the arithmetic element 208 may be configured to retrieve a specific value for a particular state variable in the state matrix, a specific weight value from the weight matrix W corresponding to this particular state variable, and a specific local field value from the local field matrix H corresponding to this particular state variable. In these or other embodiments, the arithmetic element 208 may be configured to retrieve D values ​​from the local field matrix H, the weight matrix W, and the state matrix X, respectively. For example, in some embodiments, the RPU 200 may include one or more selectors configured to select rows from the local field matrix H, the weight matrix W, and the state matrix X, respectively, and provide the selected rows to the arithmetic element 208. In some embodiments, one or more selectors may include one or more D-to-1 multiplexers. Based on the retrieved values, the arithmetic element 208 may be configured to perform arithmetic operations related to determining changes in energy that may correspond to changes in the state of the corresponding state variable.

[0056] For example, the arithmetic element 208 is the current local field value of each state variable ("h old Based on the state variables ("w") and the weight values ​​of each state variable, if the state of each state variable should have been changed, a new local field value (h) for each state variable is generated. new) can be configured to determine. For example, in an example where the received value of each state variable indicates that each state variable is flipped to "on" (e.g., the received value is "1"), the arithmetic element 208 can perform the following equation (7) with respect to the corresponding local field value and weight value.

number

[0057] As another example, in a case where the received value of each state variable indicates that each state variable is inverted to "off" (for example, the received value is "0"), the arithmetic element 208 can perform the following equation (8) with respect to the corresponding local field value and weight value.

number

[0058] In these or other embodiments, the arithmetic element 208 may be configured to obtain the change in the system's energy that may occur by inverting the bits using the newly determined local field value. In these or other embodiments, the arithmetic element 208 may be configured to perform any appropriate arithmetic operation on any appropriate expression that may be used to determine the change in energy.

[0059] For example, in a typical Boltzmann machine, the arithmetic element 208 determines the corresponding change in the system's energy by using the corresponding local field "h i h new Using the state value "x i It may be configured to use " to perform the following equation (9).

number

[0060] As another example, as mentioned above, in exactly 1 row-clustered Boltzmann machine, only one state variable of a row is on, and at a time, one state variable of a row must be on. Therefore, a proposed change in the state of one state variable of a row affects the other state variable of the row. Thus, in the case of a row-clustered Boltzmann machine, the arithmetic element 208 is for each of the two state variables that can be changed. new It can be configured to determine the corresponding change in the energy of the system by performing equation (3) discussed above, in which each h new This is used in equation (3).

[0061] As another example, as mentioned above, in exactly 1 cross-clustered Boltzmann machine, only one state variable of the cross-cluster is on, and at one time only one state variable of the cross-cluster must be on. Therefore, a proposed change in the state of one state variable of the cluster will also affect the other state variable of the cluster. Thus, in the case of a cross-row clustered Boltzmann machine, the arithmetic element 208 is for each of the two state variables that can be changed. new It can be configured to determine the corresponding change in the energy of the system by performing equation (4) discussed above, in which each h new The corresponding weights are used in equation (4). Note that in the case of a cross-clustered Boltzmann machine, the value of w that may be used in equation (4) may be determined from the first and second matrices described above with respect to the weight block 206, as described in detail in U.S. Patent Application No. 16 / 849,887. In these or other embodiments, the RPU 200 may include a logic block 212 (indicated as "L" in Figure 2A) containing one or more further elements, as described in U.S. Patent Application No. 16 / 849,887, to determine the value of w.

[0062] As part of each trial associated with each state variable, the decision element 210 may be configured to decide whether to accept or reject a state change proposal for each state variable, such as in the method described above. Furthermore, or alternatively, multiple trials may be executed in parallel by the arithmetic element 208 and the decision element 210. In these or other embodiments, the decision element 210 may be configured to randomly select an acceptable state change from other acceptable state changes as the state change to be actually implemented. For example, the decision element 210 may use a tournament reduction tree to select one of the acceptable state changes.

[0063] The RPU200 may be configured to update the values ​​of the state matrix X, local field matrix H, and weight matrix W based on the accepted state changes selected for implementation. For example, h corresponding to the state changes to be implemented new The value of may be added to the corresponding entry in the local field matrix H. Furthermore, the state of the variable corresponding to the change being made can be changed. Furthermore, the weight values ​​of the weights corresponding to the variable being changed can be updated. For example, for a variable that is changed from "off" to "on", the corresponding weight value will be updated there. new It may also be changed by adding the value of . As another example, for a variable that is changed from "on" to "off", the corresponding weight value is then . new The value may be changed by subtracting from it. In some embodiments, the arithmetic element 208 may be configured to perform an arithmetic update operation. Furthermore, or instead, one or more other update operations may be performed by the decision element 210 and / or the arithmetic element 208.

[0064] As described above, the RPU200 may be configured to perform parallel trials with respect to different variables of the state matrix X. Furthermore, the degree of parallelism may be varied or adjusted. For example, as described above, the arithmetic element 208 and the decision element 210 may be configured to perform up to D trials at a time. In the example where the total number of elements in the state matrix X is less than or equal to D, the RPU200 may be able to perform trials for each state variable simultaneously. In these or other embodiments, the RPU200 may randomly select one or more of the accepted state changes to be performed from the accepted state changes determined during the parallel execution of trials (for example, using the decision element 210). Such operation may be called fully parallel mode and performs fully parallel trials.

[0065] In these or other embodiments, in cases where the total number of elements in the state matrix X is greater than D, the RPU 200 can operate in a sequential parallel mode in which sequential parallel trials can be performed. During sequential parallel mode, each set of D trials can be executed. Furthermore, the D trials may be executed in parallel for each set. In addition, one of the accepted changes determined during each set of trials may be selected as the "winner" of each set (e.g., using a tournament reduction tree) as described above. In some embodiments, each winner of each set may be stored by the RPU 200 (e.g., in the RPU's registers).

[0066] In these or other embodiments, one or more further sets may be executed sequentially, and each winner of each of these further sets may be further remembered. Furthermore, or alternatively, after a certain number of sets have been executed, one of the winners of one of the sets may be selected from the other winners as a change to be implemented. For example, the winners of a set may be provided to a tournament abbreviation tree, which can then randomly select one of the winners as a change to be implemented.

[0067] Furthermore, or alternatively, the RPU200 may be configured to operate in sequential fully parallel mode. In sequential fully parallel mode, the number of sets of trials that can be performed can be such that trials are performed for every variable in the state matrix X before the final winner is selected.

[0068] In some embodiments as described above, the state matrix X and the local field matrix H can be configured and sized such that each row of the state matrix X and the local field matrix H contains D elements. Therefore, in some embodiments, the RPU200 may be configured to perform row-by-row sequential parallel trials, where each set of trials corresponds to each row of the state matrix X.

[0069] The operation of the RPU 200 in sequential parallel mode may vary slightly depending on whether the RPU 200 is running a normal Boltzmann machine or a clustered Boltzmann machine, such as a row-clustered Boltzmann machine. For example, in some embodiments, the RPU 200 may include a D-to-1 multiplexer 214. The D-to-1 multiplexer 214 may not be used during sequential parallel mode while running a normal Boltzmann machine. However, during sequential parallel mode while running a row-clustered Boltzmann machine, the D-to-1 multiplexer 214 may be configured to select a local field value corresponding to the "on" variable of each row currently being processed. This local field value can then be sent to the arithmetic element 208, as described above, and used to determine the change in energy for each trial of each of the other state variables of each row. In these or other embodiments, assuming that the arithmetic element 208 can perform an action for each trial for each state variable of the row (e.g., one for each state variable and one for the currently "on" variable), the arithmetic element 208 can perform further arithmetic cycles of the row-clustered Boltzmann machine.

[0070] In these or other embodiments, the RPU200 can operate in a strict serial mode, where only one trial can be executed at a time. In some embodiments, the operation of the RPU200 while running a cross-clustered Boltzmann machine may be configured to allow the RPU200 to operate in strict serial mode. Furthermore, or alternatively, parallel processing that may occur while running a normal Boltzmann machine or a row-clustered Boltzmann machine may be excluded so that the RPU200 can operate in strict serial mode while running these types of Boltzmann machines as well.

[0071] The degree of parallelism used between trials can help solve optimization problems more quickly. For example, in some embodiments, an optimization problem may be determined to be solved when the energy of the system is maximized or minimized. In such cases where the energy is maximized or minimized, there can be no further acceptable state changes. Furthermore, as the problem approaches a solution, the acceptance rate of state changes may decrease. By performing parallel trials, the number of trials performed at one time can be increased, allowing for a faster arrival at the solution.

[0072] However, the amount of parallel processing used can also increase the use of processing resources. Therefore, in some cases (e.g., cases with relatively high acceptance rates), having a high degree of parallelism may not be very efficient. Accordingly, in some embodiments, the degree of parallelism performed by the RPU200 may be adjusted based on the acceptance rate of state changes of state variables.

[0073] For example, the controller 284 may be communicatively coupled to the decision element 210 and may be configured to track which proposed changes for individual variables are acceptable and which are rejected. In these or other embodiments, the controller 284 may be configured to determine the acceptance rate of the proposed changes.

[0074] In some embodiments, the controller 284 may be configured to adjust the degree of parallelism based on a determined acceptance rate. For example, the controller 284 may be configured to increase the degree of parallelism when the acceptance rate decreases. Alternatively, the controller 284 may be configured to decrease the degree of parallelism when the acceptance rate increases. For example, in some embodiments, in response to an acceptance rate that is above a first threshold corresponding to a relatively high acceptance rate, the controller 284 may instruct the RPU 200 to operate in sequential mode. Alternatively, in response to an acceptance rate that is between the first threshold and a second threshold lower than the first threshold, the controller 284 may instruct the RPU 200 to operate in incompletely parallel sequential mode. In these or other embodiments, in response to an acceptance rate that is between a second threshold and a third threshold lower than the second threshold, the controller 284 may instruct the RPU 200 to operate in fully parallel sequential mode. Furthermore, or alternatively, in response to an acceptance rate that is between a third threshold and a fourth threshold lower than the third threshold, the controller 284 may instruct the RPU 200 to operate in fully parallel mode, if available as an option.

[0075] Furthermore, or alternatively, in some examples, solving the optimization problem can lead to a maxima or minima, where the acceptance rate may be zero or near zero, but the total energy of the system may not be the actual minimum or maximum. In some embodiments, and as will be discussed in more detail below, the RPU200 may be configured such that an offset can be applied to each of one or more of the local field values ​​to help move the optimization process away from the maxima or minima. In some embodiments, the application of the offset can be based on a determined acceptance rate.

[0076] For example, in some embodiments, the controller 284 may be configured to apply an offset to the local field used for the trial in response to an acceptance rate of zero or near zero. In some embodiments, the controller 284 may be configured to apply an initial offset to the local field. For example, the initial offset may be provided to an arithmetic element 208, which may be instructed to add or subtract the initial offset to one or more local field values ​​of the local field matrix H used in later trials.

[0077] In some embodiments, the initial offset value may be a number provided by the user or a default number provided to the controller 284. In these or other embodiments, the initial offset value may be selected based on the current local field value. For example, in some embodiments, the highest local field value included in the local field matrix H may be used as the initial offset. In these or other embodiments, the use of the highest local field value as the initial offset may be such that the highest local field value is subtracted from the local field value. Furthermore or alternatively, in some embodiments, the lowest local field value included in the local field matrix H may be used as the initial offset instead of the highest local field value.

[0078] In these or other embodiments, the controller 284 may be configured to determine the highest local field value using the decision element 210. For example, the candidate reduction tree of the decision element 210 may be supplied with local field values ​​and instructed to output the highest value. In some examples, the decision element 210 can perform row-by-row comparisons so that the highest local field value for each row of the local field matrix H can be obtained. In these or other embodiments, the highest value for each row may be stored and then provided to the decision element 210 to determine the highest value for the entire local field matrix H.

[0079] Following the application of the initial offset, the controller 284 can then instruct one or more trials to be performed with the initial offset applied, and the acceptance rate can be evaluated after the trials are performed. In some embodiments, the controller 284 can instruct each trial to be performed for each state variable before the acceptance rate is re-evaluated. In some embodiments, in response to the acceptance of at least one state change proposal, the controller 284 may be configured to instruct that the offset is no longer applied.

[0080] In these or other embodiments, in response to a proposed change being unacceptable, the controller 284 may be configured to instruct the initial offset to make a change. For example, the controller 284 may increment the initial offset by a certain amount. For example, in some embodiments, the initial offset may be incremented by the highest local field value. In some embodiments, the controller 284 may be configured to iteratively increment the offset and perform trials until the change is accepted.

[0081] In some embodiments, two or more RPUs may be merged to increase the amount of parallel processing that can be performed, thereby allowing more than D trials to be performed at once. For example, Figure 2B shows a merged RPU250 including a first RPU252a and a second RPU252b, each configured to operate as a normal Boltzmann machine. In Figure 2B, each RPU252 may be similar to the RPU200 in Figure 2A. The merged RPU250 may further include a further decision element 216 configured to take the output of the respective decision elements of the first RPU252a and the second RPU252b (e.g., selected accepted state changes for each variable in the state matrices of the first RPU252a and the second RPU252b). The decision element 216 may be configured to randomly select one of the taken outputs as the variable state to change.

[0082] Figure 2C shows another example of a merged RPU. More specifically, Figure 2C shows a merged RPU 260 including a first RPU 262a and a second RPU 262b, each configured to operate as a row-clustered Boltzmann machine. In Figure 2C, each RPU 262 may be similar to the RPU 200 in Figure 2A. The merged RPU 260 may further include a further decision element 264, which may be similar to the decision element 216 in Figure 2B. Furthermore, the first RPU 262a may include a D-to-1 multiplexer 266a, and the second RPU 262b may include a D-to-1 multiplexer 266b. The D-to-1 multiplexer 266 may be similar to the D-to-1 multiplexer 214 in Figure 2A. Furthermore, the merged RPU260 may include a 2-to-1 multiplexer that can be configured to select one of the outputs of these D-to-1 multiplexers 266. Additionally, the merged RPU260 may include routes to each arithmetic element of each RPU262 that allow switching between local fields corresponding to the "on" state variable of each row.

[0083] Figure 2D shows another example of a merged RPU. More specifically, Figure 2D shows a merged RPU 270 including a first RPU 272a and a second RPU 272b, each configured to operate as a cross-clustered Boltzmann machine. In Figure 2D, each RPU 272 may be similar to the RPU 200 in Figure 2A. The merged RPU 270 may further include a further decision element 274, which may be similar to decision element 216 in Figure 2B. Furthermore, the first RPU 272a may include a logical block 276a, and the second RPU 272b may include a logical block 276b. The logical block 276 may be similar to the combination of decision element 210 and logical block 212 in Figure 2A.

[0084] It should be noted that each of the merged RPUs shown in Figures 2B to 2D may be implemented using the same set of hardware components. For example, a merged RPU may have a hardware configuration similar to or identical to that of merged RPU270. In these or other embodiments, when implementing a particular type of Boltzmann machine, there may be elements that are not applicable to this particular type of Boltzmann machine, but which do not need to be used.

[0085] In addition to the ability to merge multiple RPUs 200 to perform further parallel processing on a specific replica of the system, multiple RPUs 200 may be configured to operate to run a replica exchange process. In these or other embodiments, one or more RPUs 200 may be configured to run a different replica in the replica exchange process. Furthermore, or alternatively, two or more different RPUs 200 running different replicas may be configured to run different types of systems. For example, one RPU may run a normal Boltzmann machine, another RPU may run a row-clustered Boltzmann machine, and / or another RPU may run a cross-clustered Boltzmann machine. An example of RPUs 200 used to run the replica exchange process is given below with respect to Figure 4.

[0086] As an example, Figure 2E shows an exemplary system 280 that may be configured to perform a replica exchange process using multiple RPUs 200. For example, system 280 may include a group 282 of RP units (RPUnits), each of which may be an RPU 200 or a merged RPU as described above. System 280 may further include a controller 284 ("controller 284"), which may be configured to direct the replica exchange process.

[0087] The controller 284 may be configured to acquire different states of replicas executed by different RP units, and thus can coordinate the replica exchange process according to any appropriate technique. Furthermore, the controller 284 may be configured to instruct different RP units to perform any appropriate type of replica exchange process, such as parallel tempering, simulated annealing, etc. Alternatively, the controller 284 may be configured to instruct the loading of data from one or more applicable external sources into different blocks of the RP units. In these or other embodiments, the controller 284 may be configured to instruct the different RP units regarding the type of system they may implement. For example, the controller 284 can instruct the operation of different RP units to run a normal Boltzmann machine, a row-clustered Boltzmann machine, and / or a cross-clustered Boltzmann machine.

[0088] Figures 2A to 2E may be modified, added to, or omitted without departing from the scope of this disclosure. For example, the specific number, size, layout, etc., of the elements may change. Furthermore, in some embodiments, the various components illustrated and described may be included on the same chip. Alternatively, one or more components may be on a different chip from one or more other components.

[0089] Figure 3 shows a block diagram of an exemplary computing system 302 configured to perform one or more operations described herein, according to at least one embodiment of the present disclosure. For example, in some embodiments, the computing system 302 may be configured to perform or direct one or more operations associated with the energy engine 102 and / or LFM 108 in Figure 1A. Furthermore or alternatively, the controller 284 in Figure 2A may include the computing system 302. In some embodiments, the computing system 302 may be included in or form part of an annealing system. The computing system 302 may include a processor 350, memory 352, and data storage device 354. The processor 350, memory 352, and data storage device 354 may be connected for communication purposes.

[0090] Generally, the processor 350 may include any suitable computer, computing entity, or processing device, including various computer hardware or software modules, and may be configured to execute instructions stored in any applicable computer-readable storage medium. For example, the processor 350 may include a microprocessor, microcontroller, digital signal processor (DSP), application-specific integrated circuit (ASIC), field-programmable gate array (FPGA), graphics processing unit (GPU), central processing unit (CPU), or any other digital or analog circuitry configured to interpret and / or execute program instructions and / or process data. Although shown as a single processor in Figure 3, the processor 350 may include any number of processors configured to individually or collectively perform or direct any number of operations described in this disclosure. Furthermore, one or more processors may reside in one or more different electronic devices, such as different servers.

[0091] In some embodiments, the processor 350 may be configured to interpret and / or execute program instructions stored in the memory 352, the data storage device 354, or the memory 352 and the data storage device 354, and / or process data. In some embodiments, the processor 350 may retrieve program instructions from the data storage device 354 and load the program instructions into the memory 352. After the program instructions are loaded into the memory 352, the processor 350 can execute the program instructions. For example, in some embodiments, the energy engine 102 in Figure 1A, the LFM engine 108, and / or the controller 284 in Figure 2A may also be software modules which are program instructions loaded into the memory 352 and can be executed by the processor 350.

[0092] The memory 352 and data storage device 354 may include computer-readable storage media storing computer-executable instructions or data structures. Such computer-readable storage media may include any available non-temporary media that can be accessed by a computer, such as a processor 350. Such computer-readable storage media may include, but are not limited to, tangible or non-temporary computer-readable storage media, including random access memory (RAM), read-only memory (ROM), electrically erasable programmable read-only memory (EEPROM), compact disk read-only memory (CD-ROM) or other optical disk storage devices, magnetic disk storage devices or other magnetic storage devices, flash memory devices (e.g., solid-state memory devices), or any other non-temporary storage media that can be used to store specific program code in the form of computer-executable instructions or data structures and that can be accessed by a computer. In these and other embodiments, the term “non-temporary” as described herein should be interpreted to exclude only the types of temporary media that were found to be outside the scope of patentable subject matter in the Federal Circuit Judgment in In re Nuijten, 500 F.3d 1346 (Fed. Cir. 2007).

[0093] The above combinations may also fall within the scope of computer-readable storage media. Computer-executable instructions may include, for example, instructions and data configured to cause the processor 350 to perform a specific operation or group of operations.

[0094] Without departing from the scope of this disclosure, modifications, additions, or omissions may be made to the computing system 302. For example, in some embodiments, the computing system 302 may include any number of other components that are not expressly illustrated or described. Furthermore, or instead, the computing system 302 may include fewer elements or be configured differently. For example, the memory 352 and / or data storage device 354 may be omitted or may be part of the same computer-readable storage medium. Furthermore, references in this disclosure to hardware or operations performed by hardware may refer to any one or more applicable operations, configurations, or combinations of elements of the computing system 302.

[0095] Figure 4 shows a flowchart of an exemplary method 400 for performing trials during the resolution of an optimization problem, according to at least one embodiment described herein. The operations of method 400 may be performed by any suitable system, apparatus, or device. For example, the energy engine 102 and / or LFM engine 108 in Figure 1A, or the RPU and / or controller in Figures 2A to 2E, or the computing system 302 in Figure 3 can perform one or more of the operations associated with method 400. Although shown in discrete blocks, the steps and operations associated with one or more blocks of method 400 may be divided into further blocks, combined into fewer blocks, or deleted, depending on the particular implementation.

[0096] In block 402, a state matrix of the system representing the optimization problem can be obtained. The state matrix may include variables that each represent a feature related to the optimization problem. For example, the state matrix X described above with respect to Figure 2A may be obtained. In some embodiments, obtaining the state matrix may include loading the state matrix into memory, for example, loading the state matrix into a state block on the RPU. Furthermore or alternatively, obtaining the state matrix may include obtaining one or more values ​​of state variables from the state block and loading them into arithmetic elements such as arithmetic element 208 in Figure 2A.

[0097] In block 404, weights corresponding to variables in the state matrix can be obtained. Each weight may be associated with one or more relationships between each variable in the state matrix and one or more other variables. In some embodiments, weights may be obtained from a weight matrix, such as the weight matrix W described above with respect to Figure 2A. In these or other embodiments, weights may be determined based on one or more other matrices, as described in U.S. Patent Application No. 16 / 849,887. In these or other embodiments, obtaining weights may include loading the weight matrix into the weight block of the RPU. Furthermore or alternatively, obtaining weights may include obtaining weights from the weight block and / or external memory and loading them into arithmetic elements such as arithmetic element 208 in Figure 2A.

[0098] In block 406, a local field matrix corresponding to the state matrix can be obtained. The local field matrix may include local field values ​​that show the interactions between the variables of the state matrix, each influenced by the respective weight of each variable. For example, the local field matrix H described above with respect to Figure 2A may be obtained. In some embodiments, obtaining the local field matrix may include loading the local field matrix into memory, for example, loading the local field matrix into a local field block on the RPU. Furthermore or alternatively, obtaining the local field matrix may include obtaining one or more local field values ​​from the local field block and loading them into arithmetic elements such as arithmetic element 208 in Figure 2A.

[0099] In block 408, a stochastic process may be performed based on weights and local field values. The stochastic process may be performed with respect to changing the state of one or more of the variables, or it may include performing trials with respect to one or more of the variables, where each trial determines whether to change the state of each of the variables. For example, in some embodiments, the stochastic process may be performed as described above with respect to Figure 2A.

[0100] In block 410, the acceptance rate for changes in the state of a variable may be determined. In block 412, the degree of parallelism for performing trials may be adjusted. In some embodiments, the degree of parallelism may be adjusted based on the acceptance rate, as described above with respect to Figure 2A. In these or other embodiments, an offset may be applied based on the acceptance rate, as described further above with respect to Figure 2A.

[0101] Method 400 can be modified, added to, or omitted without departing from the scope of this disclosure. For example, in some examples, some of the operations may be performed repeatedly. For example, in some embodiments, the operations may return to block 408 following block 412, and operations 408, 410, and 412 may be repeated. The operations of Method 400 may be performed in a different order. Furthermore, or instead, two or more operations may be performed simultaneously. Moreover, the operations and actions outlined are provided merely as examples, and some of the operations and actions may be combined with fewer operations and actions or extended to further operations and actions, without prejudice to the essence of the disclosed embodiments.

[0102] As used herein, the terms “module” or “component” may refer to a specific hardware implementation configured to perform the operation of a module or component, and / or a software object or software routine that can be stored and / or executed on general-purpose hardware of a computing system (e.g., computer-readable media, processing devices, etc.). In some embodiments, different components, modules, engines, and services described herein may be implemented as objects or processes that run on a computing system (e.g., as separate threads). Some of the systems and methods described herein are generally described as being implemented in software (stored and / or executed on general-purpose hardware), but specific hardware implementations, or combinations of software and specific hardware implementations, are also possible and intended. In this description, “computation entity” may be any computing system as previously defined herein, or any combination of modules or modulates that operate on a computing system.

[0103] In this disclosure, the terms used in particular in the attached claims (e.g., the text of the attached claims) are generally intended to be "open" terms (for example, the term "contains" should be interpreted as "contains but not limited to," the term "has" should be interpreted as "has at least," and the term "includes" should be interpreted as "contains but not limited to," etc.).

[0104] Furthermore, if a specific number of introduced claim descriptions are intended, such intention is explicitly stated in the claim; if such statement is absent, such intention does not exist. For example, for the sake of understanding, the attached claims below may include the use of the introductory phrases “at least one” and “one or more” to introduce a claim description. However, the use of such phrases should not be seen as implicitly indicating that the introduction of a claim description by the indefinite article “a” or “an” limits a particular claim containing such introduced claim descriptions to embodiments containing only one such description, even when the same claim includes the introductory phrase “one or more” or “at least one” and an indefinite article such as “a” (for example, “a” and / or “an” should be interpreted as meaning “at least one” or “one or more”). The same applies to the use of definite articles used to introduce claim descriptions.

[0105] Furthermore, even when a claim description introducing a specific number is explicitly stated, a person skilled in the art will recognize that such description should be interpreted to mean at least the number stated (for example, the statement “two descriptions” without other modifiers means at least two descriptions, or two or more descriptions). Furthermore, in examples where similar provisions are used, such as “at least one of A, B, and C, etc.” or “one or more of A, B, and C, etc.” or “at least one of A, B, or C, etc.” or “one or more of A, B, or C, etc.”, such structure is generally intended to include A alone, B alone, C alone, A and B together, A and C together, B and C together, or A, B, and C together, etc. Furthermore, the use of the term “and / or” is intended to be interpreted in this manner.

[0106] Furthermore, any separate word or phrase presenting two or more alternative terms, whether in the specification, claims, or drawings, should be understood to include the possibility of containing one of the terms, either of the terms, or both. For example, the phrase "A or B" should be understood to include the possibility of "A" or "B" or "A and B," even if the terms "and / or" are used elsewhere.

[0107] All examples and conditional language described herein are intended for educational purposes to assist readers in understanding the disclosure and the concepts to which the inventors have contributed to advancing the art, and should be considered as not being limited to the examples and conditions described herein. Although embodiments of the disclosure have been described in detail, various changes, substitutions, and modifications can be made to them without departing from the spirit and scope of the disclosure.

[0108] The following note is left regarding the above embodiment. (Note 1) A step of obtaining a state matrix of a system representing an optimization problem, wherein the state matrix includes variables that each represent a feature related to the optimization problem, The step of obtaining weights corresponding to the aforementioned variables, wherein each weight relates to one or more relationships between each of the variables in the state matrix and one or more other variables, The steps include obtaining a local field matrix containing local field values, wherein the local field values ​​represent the interactions between the variables, each influenced by the respective weights of the respective variables, and A step of performing a stochastic process with respect to changing the state of one or more of the variables based on the weights and the local field values, wherein the stochastic process includes performing trials with respect to one or more of the variables, and each trial determines whether to change the state of each of the variables. A step of determining the acceptance rate of state changes of the variable during the aforementioned stochastic process, A step of adjusting the degree of parallelism in carrying out the trials based on the acceptance rate determined above, A method that includes this. (Note 2) The method according to Appendix 1, wherein adjusting the degree of parallelism includes increasing the degree of parallelism when the acceptance rate decreases. (Note 3) The method according to Appendix 1, wherein adjusting the degree of parallelism includes decreasing the degree of parallelism when the acceptance rate increases. (Note 4) The method according to Appendix 1, further comprising the step of adjusting the offset applied to one or more local field values ​​of the local field matrix during the execution of the trial, based on the acceptance rate determined above. (Note 5) The method according to Appendix 4, wherein adjusting the offset includes increasing the offset in response to the acceptance rate being zero. (Note 6) The method according to Appendix 4, wherein adjusting the offset includes removing the offset in response to at least one change being accepted. (Note 7) The method according to Appendix 4, wherein adjusting the offset includes changing the value of the offset incrementally. (Note 8) The steps include identifying the highest local field value in the local field matrix, The step of using the highest local field value as the offset, The method described in Appendix 4, which further includes the method described in Appendix 4. (Note 9) It is a system, A state matrix representing a system that solves an optimization problem, the state matrix containing variables that each represent a feature related to the optimization problem, The weights corresponding to the aforementioned variables, each weight relating to one or more relationships between each of the variables in the state matrix and one or more other variables, A local field matrix containing local field values, wherein the local field values ​​represent the interactions between the variables, each influenced by the respective weights of the respective variables, and Memory to store and Hardware configured to perform an operation, the operation is The process involves performing a stochastic process with respect to changing the state of one or more of the variables based on the weights and the local field values, the stochastic process including performing trials with respect to one or more of the variables, each trial determining whether to change the state of each of the variables, To determine the acceptance rate of state changes of the variable during the aforementioned stochastic process, Based on the determined acceptance rate, adjust the degree of parallelism in carrying out the trials, Hardware, including A system that includes this. (Note 10) The system according to Appendix 9, wherein adjusting the degree of parallelism includes increasing the degree of parallelism when the acceptance rate decreases. (Note 11) The system according to Appendix 9, wherein adjusting the degree of parallelism includes decreasing the degree of parallelism when the acceptance rate increases. (Note 12) The system according to Appendix 9, wherein the operation further includes adjusting the offset applied to one or more local field values ​​of the local field matrix during the execution of the trial, based on the determined acceptance rate. (Note 13) The system according to Appendix 12, wherein adjusting the offset includes increasing the offset in response to the acceptance rate being zero. (Note 14) The system according to Appendix 12, wherein adjusting the offset includes removing the offset in response to the acceptance of at least one change. (Note 15) The system according to Appendix 12, wherein adjusting the offset includes gradually increasing the value of the offset. (Note 16) The aforementioned operation is, Identifying the highest local field value in the aforementioned local field matrix, Using the highest local field value as the offset, The system described in Appendix 12, which further includes the system described in Appendix 12. (Note 17) It is a system, It consists of multiple replica exchange units, and each of the multiple replica exchange units is, A state matrix representing a system that solves an optimization problem, the state matrix containing variables that each represent a feature related to the optimization problem, The weights corresponding to the aforementioned variables, each weight relating to one or more relationships between each of the variables in the state matrix and one or more other variables, A local field matrix containing local field values, wherein the local field values ​​represent the interactions between the variables, each influenced by the respective weights of the respective variables, and Memory to store and Hardware configured to perform a stochastic process with respect to changing the state of one or more of the variables based on the weights and local field values, wherein the stochastic process includes performing trials with respect to one or more of the variables, and each trial determines whether to change the state of each of the variables, Includes multiple replica replacement units, A controller configured to perform an operation, the operation being: To determine the acceptance rate of state changes of the variable during the aforementioned stochastic process, Based on the determined acceptance rate, adjust the degree of parallelism in carrying out the trials, A controller, including A system that includes this. (Note 18) The system according to Appendix 17, wherein the operation performed by the controller further includes instructing the plurality of replica processing units to perform a replica exchange process. (Note 19) The system according to Appendix 17, wherein two or more of the replica exchange units operate as merged replica exchange units with respect to the same replica of the state matrix. (Note 20) The system according to Appendix 17, wherein the operation performed by the controller further includes adjusting an offset applied to one or more local field values ​​during the execution of the trial, based on the determined acceptance rate.

Claims

1. A step of obtaining a state matrix of a system representing an optimization problem, wherein the state matrix includes variables that each represent a feature related to the optimization problem, The step of obtaining weights corresponding to the aforementioned variables, wherein each weight relates to one or more relationships between each of the variables in the state matrix and one or more other variables, The steps include obtaining a local field matrix containing local field values, wherein the local field values ​​represent the interactions between the variables, each influenced by the respective weights of the respective variables, and A step of performing a stochastic process with respect to changing the state of one or more of the variables based on the weights and the local field values, wherein the stochastic process includes performing trials with respect to one or more of the variables, and each trial determines whether to change the state of each of the variables. The steps include determining an acceptance rate, which is the probability that the state of the variable changes during the aforementioned stochastic process, A step of adjusting the degree of parallelism, which represents the number of trials that can be performed simultaneously, based on the acceptance rate determined above, How a computer executes it.

2. The method performed by the computer according to claim 1, wherein adjusting the degree of parallelism includes increasing the degree of parallelism when the acceptance rate decreases.

3. A method performed by a computer according to claim 1, wherein adjusting the degree of parallelism includes decreasing the degree of parallelism when the acceptance rate increases.

4. A method performed by a computer according to claim 1, further comprising the step of adjusting an offset applied to one or more local field values ​​of the local field matrix while performing the trial, based on the acceptance rate determined above.

5. A method performed by a computer according to claim 4, wherein adjusting the offset includes increasing the offset in response to the acceptance rate being zero.

6. The method performed by the computer according to claim 4, wherein adjusting the offset includes removing the offset in response to at least one change being accepted.

7. The method performed by a computer according to claim 4, wherein adjusting the offset includes gradually increasing the value of the offset.

8. The steps include identifying the highest local field value in the local field matrix, The step of using the highest local field value as the offset, A method performed by a computer according to claim 4, further comprising:

9. It is a system, A state matrix representing a system that solves an optimization problem, the state matrix containing variables that each represent a feature related to the optimization problem, The weights corresponding to the aforementioned variables, each weight relating to one or more relationships between each of the variables in the state matrix and one or more other variables, A local field matrix containing local field values, wherein the local field values ​​represent the interactions between the variables, each influenced by the respective weights of the respective variables, and Memory to store and Hardware configured to perform an operation, the operation is The process involves performing a stochastic process with respect to changing the state of one or more of the variables based on the weights and the local field values, the stochastic process including performing trials with respect to one or more of the variables, each trial determining whether to change the state of each of the variables. Determining the acceptance rate, which is the probability that the state of the variable changes during the aforementioned stochastic process, Based on the determined acceptance rate, the degree of parallelism, which represents the number of trials that can be performed simultaneously, is adjusted. Hardware, including A system that includes this.

10. The system according to claim 9, wherein adjusting the degree of parallelism includes increasing the degree of parallelism when the acceptance rate decreases.

11. The system according to claim 9, wherein adjusting the degree of parallelism includes decreasing the degree of parallelism when the acceptance rate increases.

12. The system according to claim 9, wherein the operation further comprises adjusting an offset applied to one or more local field values ​​of the local field matrix during the execution of the trial, based on the determined acceptance rate.

13. The system according to claim 12, wherein adjusting the offset includes increasing the offset in response to the acceptance rate being zero.

14. The system according to claim 12, wherein adjusting the offset includes removing the offset in response to at least one change being accepted.

15. The system according to claim 12, wherein adjusting the offset includes gradually increasing the value of the offset.

16. The aforementioned operation is, Identifying the highest local field value in the aforementioned local field matrix, Using the highest local field value as the offset, The system according to claim 12, further comprising:

17. It is a system, It consists of multiple replica exchange units, and each of the multiple replica exchange units is, A state matrix representing a system that solves an optimization problem, the state matrix containing variables that each represent a feature related to the optimization problem, The weights corresponding to the aforementioned variables, each weight relating to one or more relationships between each of the variables in the state matrix and one or more other variables, A local field matrix containing local field values, wherein the local field values ​​represent the interactions between the variables, each influenced by the respective weights of the respective variables, and Memory to store and Hardware configured to perform a stochastic process with respect to changing the state of one or more of the variables based on the weights and local field values, wherein the stochastic process includes performing trials with respect to one or more of the variables, and each trial determines whether to change the state of each of the variables, Includes multiple replica replacement units, A controller configured to perform an operation, the operation being: Determining the acceptance rate, which is the probability that the state of the variable changes during the aforementioned stochastic process, Based on the determined acceptance rate, the degree of parallelism, which represents the number of trials that can be performed simultaneously, is adjusted. A controller, including A system that includes this.

18. The system according to claim 17, wherein the operation performed by the controller further includes instructing the plurality of replica exchange units to perform a replica exchange process.

19. The system according to claim 17, wherein two or more of the replica exchange units operate as merged replica exchange units with respect to the same replica of the state matrix.

20. The system according to claim 17, wherein the operation performed by the controller further includes adjusting an offset applied to one or more local field values ​​during the execution of the trial, based on the determined acceptance rate.

Images