Package: simulated-bifurcation
Simulated Bifurcation for PythonTheSimulated Bifurcation(SB) algorithm is a fast and highly parallelizable state-of-the-art algorithm for combinatorial optimization inspired by quantum physics and spins dynamics. It relies on Hamiltonian quantum mechanics to find local minima ofIsingproblems. The last accuracy tests showed a median optimality gap of less than 1% on high-dimensional instances.This open-source package utilizesPyTorchto leverage GPU computations, harnessing the high potential for parallelization offered by the SB algorithm.It also provides an API to define Ising models or other NP-hard and NP-complete problems (QUBO, Karp problems, ...) that can be solved using the SB algorithm.⚙️ InstallCompute PlateformCPUGPUInstructionspip install simulated-bifurcationInstallPyTorchwith GPU supportpip install simulated-bifurcation🧪 TheSimulated Bifurcation(SB) algorithmIsing modelAn Ising problem, given a null-diagonal square symmetrical matrix $J$ of size $N \times N$ and a vector $h$ of size $N$, consists in finding the spin vector $\mathbf{s} = (s_{1}, ... s_{N})$ called theground state, (each $s_{i}$ being equal to either 1 or -1) such that the following value, calledIsing energy, is minimal:$$- \frac{1}{2} \sum_{i=1}^{N} \sum_{j=1}^{N} J_{ij}s_{i}s_{j} + \sum_{i=1}^{N} h_{i}s_{i}$$This problem is known to be NP-hard but is very useful since it can be used in many sectors such as finance, transportation or chemistry or derived as other well-know optimization problems (QUBO, MAXCUT, Knapsack problem, etc.).The Simulated Bifurcation algorithm was originally introduced to solve Ising problems by simulating the adiabatic evolution of spins in a quantum Hamiltonian system, but can also be generalized to a wider range of optimization problems.Usage on polynomial instancesThe SB algorithm can be written as the minimization or maximization of multivariable polynomials of degree two, i.e. written as$$\sum_{i=1}^{N} \sum_{j=1}^{N} M_{ij}x_{i}x_{j} + \sum_{i=1}^{N} v_{i}x_{i} + c$$for which the $x_{i}$'s can be spins, binary or non-negative integer.This can also be seen as the sum of a quadratic form, a linear form and a constant term and such a formulation is the basis of many optimization problems.Theminimizeandmaximizefunctions allow to respectively minimize and maximize the value of such polynomials for a given type of input values, relying on the SB algorithm. They both return the optimal polynomial value found by the SB algorithm, along with its associated input vector.The input types must be passed to thedomainargument:spin(default value) for a spin optimization: the optimal vector will only have ±1 valuesbinaryfor a binary optimization: the optimal vector will only have 0 or 1 valuesintXfor aX-bits encoded integer optimization: the optimal vector will only have integer value encoded withXbits or less, i.e. belonging to the range 0 to $2^{X} - 1$.For instance, 9-bits integer correspond to theint9input type and the accepted values span from 0 to 511.importsimulated_bifurcationassbmatrix=torch.tensor([[0,1,2],[1,0,-2],[2,-2,0]])vector=torch.tensor([-1,0,2])constant=2.0Minimization# Spin minimizationspin_value,spin_vector=sb.minimize(matrix,vector,constant,domain='spin')# Binary minimizationbinary_value,binary_vector=sb.minimize(matrix,vector,constant,domain='binary')# 3-bits integer minimizationint_value,int_vector=sb.minimize(matrix,vector,constant,domain='int3')Maximization# Spin maximizationspin_value,spin_vector=sb.maximize(matrix,vector,constant,domain='spin')# Binary maximizationbinary_value,binary_vector=sb.maximize(matrix,vector,constant,domain='binary')# 10-bits integer maximizationint_value,int_vector=sb.maximize(matrix,vector,constant,domain='int10')For both functions, only the matrix is required, the vector and constant terms are optional.Parallelization (multi-agent search)The Simulated Bifurcation algorithm is highly parallelizable since it only relies on linear matrices equations. To take advantage of this property, this implementation offers the possibility to perform a multi-agent search of the optimal solution by evolving several spin vectors in parallel (each one being called anagent). The number of agents is set by theagentsparameter in theminimizeandmaximizefunctions.💡 Tip:it is faster to run once the algorithm with N agents than to run N times the algorithm with only one agent.# Efficient computation ✔️sb.minimize(matrix,agents=100)# Slower cumbersome computation ❌for_inrange(100):sb.minimize(matrix,agents=1)GPU computationThis parallelization of the algorithm can also be utilized by performing calculations on GPUs to speed them up significantly. To do this, simply specify the calculationdeviceargument tocudawhen instantiating an Ising model:sb.minimize(matrix,device='cuda')Early stoppingThe Simulated Bifurcation algorithm stops after a certain number of iterations, defined by the parametermax_stepsof theminimizeandmaximizefunctions. However, this implementation comes with the possibility to perform early stopping and save computation time by defining convergence conditions.At regular intervals, the energy of the agents is sampled and compared with its previous value to calculate their stability period. If an agent's stability period exceeds a convergence threshold, it is considered to have converged and its value is frozen. If all agents converge before the maximum number of iterations has been reached, the algorithm stops.The sampling period and the convergence threshold are respectively set using thesampling_periodandconvergence_thresholdparameters of theminimizeandmaximizefunctions.To use early stopping in the SB algorithm, set theuse_windowparameter toTrue.If only some agents have converged when the maximum number of iterations is reached, the algorithm stops and only these agents are considered in the results.# Stop with maximal iterationssb.minimize(matrix,max_steps=10000)# Early stoppingsb.minimize(matrix,sampling_period=30,convergence_threshold=50,use_window=True,)Optimization resultsBy default, SB returns the best vector and objective value found. However, it is also possible to configure it to so it returns all the vectors for each agent with the associated objective value. To do so, thebest_onlyparameter of theminimizeandmaximizefunctions must be set toFalse(default isTrue).best_vector,best_value=sb.minimize(matrix,best_only=True)vectors,values=sb.maximize(matrix,best_only=False)💡 Advanced usagesThis section deals with a more complex use of the SB algorithm, as it is closer to the quantum theory from which it is derived. To better understand the significance of the subjects at stake, we recommend reading the theory behind the SB algorithm by Gotoet al..Goto, H., Tatsumura, K., & Dixon, A. R. (2019). Combinatorial optimization by simulating adiabatic bifurcations in nonlinear Hamiltonian systems.Science advances, 5(4), eaav2372.Kanao, T., & Goto, H. (2022). Simulated bifurcation assisted by thermal fluctuation.Communications Physics, 5(1), 153.Goto, H., Endo, K., Suzuki, M., Sakai, Y., Kanao, T., Hamakawa, Y., ... & Tatsumura, K. (2021). High-performance combinatorial optimization based on classical mechanics.Science Advances, 7(6), eabe7953.SB Algorithm modesThe SB algorithm is available in four different versions (Gotoet al.) that result in small variations in the algorithm general operation. The four modes are:Ballistic SB (bSB): uses the particles' position for the SB matrix computations; usually faster but less accurate.Discrete SB (dSB): uses the sign of the particles' position for the SB matrix computations; usually slower but more accurate.Heated ballistic SB (HbSB): uses the bSB algorithm with a supplementary non-symplectic term to allow a higher solution space exploration.Heated discrete SB (HdSB): uses the dSB algorithm with a supplementary non-symplectic term to allow a higher solution space exploration.These mode can be selected setting the parametersballisticandheatedto eitherTrueorFalsein theIsing.optimizemethod or theminimize/maximizefunctions.sb.minimize(matrix,ballistic=True,heated=False)# bSBsb.minimize(matrix,ballistic=False,heated=True)# HdSBsb.maximize(matrix,ballistic=False,heated=False)# dSBsb.maximize(matrix,ballistic=True,heated=True)# HbSBSB Algorithm's hyperparameters settingThe SB algorithm has a set of hyperparameters corresponding to physical constants derived from quantum theory, which have been fine-tuned (Gotoet al.) to give the best results most of the time. Nevertheless, the relevance of specific hyperparameters may vary depending on the properties of the instances. For this purpose, theset_envfunction can be used to modify their value.# Custom hyperparameters valuessb.set_env(time_step=.1,pressure_slope=.01,heat_coefficient=.06)# Default hyperparameters valuessb.reset_env()Derived optimization modelsA lot of mathematical problems (QUBO, Travelling Salesman Problem, MAXCUT, ...) can be written as order-two multivariate polynomials problems, and thus can be solved using the Simulated Bifurcation algorithm. Some of them are already implemented in themodelsmodule:🔬 PhysicsIsing model📐 MathematicsQuadratic Unconstrained Binary Optimization (QUBO)Number partitioning💸 FinanceMarkowitz modelCustom modelsYou are also free to create your own models using our API. Depending on the type of model you wish to implement, you cen create a subclass of one of theSpinQuadraticPolynomial,BinaryQuadraticPolynomialorIntegerQuadraticPolynomialAPIs to quickly and efficiently link your custom model to an Ising problem and solve it using the SB algorithm.The advantage of doing so is that your model can directly call theoptimizemethod that it inherits from theBaseMultivariateQuadraticPolynomialinterface without having to redefine it.For instance, here is how the QUBO model was implemented:The QUBO problem consists, given an upper triangular matrix $Q$, in finding the binary vector that minimizes the value
$$\sum_{i=1}^{N} \sum_{j=1}^{N} Q_{ij}x_{i}x_{j}$$fromsimulated_bifurcationimportBinaryQuadraticPolynomialclassQUBO(BinaryQuadraticPolynomial):def__init__(self,Q,dtype,device)->None:super().__init__(matrix=Q,vector=None,constant=None,dtype=dtype,device=device)self.Q=self.matrixYou can check Andrew Lucas' paper on Ising formulations of NP-complete and NP-hard problems, including all of Karp's 21 NP-complete problems.🔎 Lucas, A. (2014). Ising formulations of many NP problems.Frontiers in physics, 2, 5.🔗 Cite this workIf you are using this code for your own projects please cite our work:@software{Ageron_Simulated_Bifurcation_SB_2023,author={Ageron, Romain and Bouquet, Thomas and Pugliese, Lorenzo},month=nov,title={{Simulated Bifurcation (SB) algorithm for Python}},url={https://github.com/bqth29/simulated-bifurcation-algorithm},version={1.2.1},year={2023},}