(phRtSrSSKrSSKrSSKrSSKrSSKJrJ r S/r \R"S\RRS9\R"S\RRS94r \R"\ S9r"S S 5r"S S 5r"S S5r"SS5r"SS5r"SS5r\ "SSSS9SSSS.Sjj5rg)z> basinhopping: The basinhopping global optimization algorithm N)check_random_state_transition_to_rng basinhoppingres_new)kindres_old) parametersc0\rSrSrSrSrSrSrSrSr g) Storagez1 Class used to store the lowest energy structure c&URU5 gN)_addselfminress O/var/www/html/venv/lib/python3.13/site-packages/scipy/optimize/_basinhopping.py__init__Storage.__init__s &cnXl[R"UR5URlgr)rnpcopyxrs rr Storage._adds ) rcUR(aQURURR:dURR(dURU5 gg)NTF)successfunrrrs rupdateStorage.updates; >>vzzDKKOO;&*kk&9&9 IIf rcUR$rr)rs r get_lowestStorage.get_lowest%s {{rr"N) __name__ __module__ __qualname____firstlineno____doc__rrrr#__static_attributes__rrr r s*rr c4\rSrSrSrS SjrSrSrSrSr g) BasinHoppingRunner)aThis class implements the core of the basinhopping algorithm. x0 : ndarray The starting coordinates. minimizer : callable The local minimizer, with signature ``result = minimizer(x)``. The return value is an `optimize.OptimizeResult` object. step_taking : callable This function displaces the coordinates randomly. Signature should be ``x_new = step_taking(x)``. Note that `x` may be modified in-place. accept_tests : list of callables Each test is passed the kwargs `f_new`, `x_new`, `f_old` and `x_old`. These tests will be used to judge whether or not to accept the step. The acceptable return values are True, False, or ``"force accept"``. If any of the tests return False then the step is rejected. If ``"force accept"``, then this will override any other tests in order to accept the step. This can be used, for example, to forcefully escape from a local minimum that ``basinhopping`` is trapped in. disp : bool, optional Display status messages. c[R"U5UlX lX0lX@lXPlSUl[RR5Ul SURl U"UR5nUR(d;UR=RS- sl UR (a [S5 [R"UR5UlURUlX`lUR (a$[SURUR 4-5 [%U5Ul[)US5(aUR*URl[)US5(aUR,URl[)US5(aUR.URlgg)Nr1warning: basinhopping: local minimization failurezbasinhopping step %d: f %gnfevnjevnhev)rrr minimizer step_taking accept_testsdispnstepscipyoptimizeOptimizeResultresminimization_failuresrprintrenergyincumbent_minresr storagehasattrr2r3r4)rx0r5r6r7r8rs rrBasinHoppingRunner.__init__@s9"&(  >>002)*&466"~~ HH * *a / *yyIJ"jj & 99 .$**dkk1JJ Kv 66 " ""KKDHHM 66 " ""KKDHHM 66 " ""KKDHHM #rcJ[R"UR5nURU5nUR U5nURnUR nUR (d;UR=RS- slUR(a [S5 [US5(a)UR=RUR- sl [US5(a)UR=RUR- sl [US5(a)UR=RUR- slSnURHqn[ R""U5[$:XaU"X R&S9nOU"XCUR(URS9nUS :XaSn OUc [+S 5eU(aMoS nMs [URS 5(a/URR-XTX0R(URS9 XR4$) zDo one Monte Carlo iteration Randomly displace the coordinates, minimize, and decide whether or not to accept the new coordinates. r0r1r2r3r4T)rr)f_newx_newf_oldx_oldz force acceptz7accept_tests must return True, False, or 'force accept'Freport)rrrr6r5rrr=r>r8r?rCr2r3r4r7inspect signature_new_accept_test_signaturerAr@ ValueErrorrK)r x_after_steprx_after_quenchenergy_after_quenchaccepttesttestress r_monte_carlo_step$BasinHoppingRunner._monte_carlo_stepcswwtvv '' 5  -$jj~~ HH * *a / *yyIJ 66 " " HHMMV[[ (M 66 " " HHMMV[[ (M 66 " " HHMMV[[ (M%%D  &*DDv7L7LM%8%)[[@.( "233W&$ 4##X . .    # #F*8 *.&& $ 2~rcU=RS- slSnUR5up#U(aWURUl[R "UR 5UlX0lURRU5nUR(aGURURU5 U(a$[SURUR4-5 UR Ul URUlX lU$)z3Do one cycle of the basinhopping algorithm r0Fz:found new global minimum on step %d with function value %g)r9rVrr@rrrrArBrr8 print_reportr?xtrial energy_trialrS)rnew_global_minrSrs r one_cycleBasinHoppingRunner.one_cycles a //1  **DKWWVXX&DF$* !!\\008N 99   fjj& 1"%)ZZ$=>?hh "JJ rcURR5n[SURURUX#R 4-5 g)zprint a status updatez>basinhopping step %d: f %g trial_f %g accepted %d lowest_f %gN)rBr#r?r9r@r)rr[rSrs rrYBasinHoppingRunner.print_reportsA((*  $ DKK &  44 5r) rSr7r8r@r[rAr5r9r=r6rBrrZN)F) r%r&r'r(r)rrVr]rYr*r+rrr-r-)s,!(F7r85rr-c>\rSrSrSrS SjrSrSrSrSr Sr g ) AdaptiveStepsizeal Class to implement adaptive stepsize. This class wraps the step taking class and modifies the stepsize to ensure the true acceptance rate is as close as possible to the target. Parameters ---------- takestep : callable The step taking routine. Must contain modifiable attribute takestep.stepsize accept_rate : float, optional The target step acceptance rate interval : int, optional Interval for how often to update the stepsize factor : float, optional The step size is multiplied or divided by this factor upon each update. verbose : bool, optional Print information about each update cjXlX lX0lX@lXPlSUlSUlSUlg)Nr)takesteptarget_accept_rateintervalfactorverboser9 nstep_totnaccept)rre accept_ratergrhris rrAdaptiveStepsize.__init__s1 "-     rc$URU5$r) take_steprrs r__call__AdaptiveStepsize.__call__s~~a  rc URRn[UR5UR- nX R :a*UR=RUR -slO)UR=RUR -slUR(a:[SUSSUR SSURRSSUS35 gg)Nz#adaptive stepsize: acceptance rate fz target z new stepsize gz old stepsize ) restepsizefloatrkr9rfrhrir?)r old_stepsizerls r_adjust_step_size"AdaptiveStepsize._adjust_step_sizes}}-- DLL)DJJ6 00 0 MM " "dkk 1 " MM " "dkk 1 " << 7 Ah,,Q/~]]++A.n\!U(aU=RS- slgg)z7called by basinhopping to report the result of the stepr0N)rk)rrSkwargss rrKAdaptiveStepsize.reports  LLA L r)rhrgrkr9rjrerfriN)?2?T) r%r&r'r(r)rrqryrorKr*r+rrrbrbs+,GJ ! O rrbc(\rSrSrSrSSjrSrSrg)RandomDisplacementiaAdd a random displacement of maximum size `stepsize` to each coordinate. Calling this updates `x` in-place. Parameters ---------- stepsize : float, optional Maximum stepsize in any dimension rng : {None, int, `numpy.random.Generator`}, optional Random number generator Nc0Xl[U5Ulgr)rvrrng)rrvrs rrRandomDisplacement.__init__s %c*rcXRRUR*UR[R"U55- nU$r)runiformrvrshaperps rrqRandomDisplacement.__call__s9 XX  t}}ndmm hhqk+ +r)rrv)rNr%r&r'r(r)rrqr*r+rrrrs +rrc(\rSrSrSrSSjrSrSrg)MinimizerWrapperiz0 wrap a minimizer function as a minimizer class Nc (XlX lX0lgr)r5funcr~)rr5rr~s rrMinimizerWrapper.__init__s"  rcURcUR"U40URD6$UR"URU40URD6$r)rr5r~)rrDs rrqMinimizerWrapper.__call__"sB 99 >>"4 4 4>>$))R?4;;? ?r)rr~r5rrr+rrrrs @rrc.\rSrSrSrSSjrSrSrSrg) Metropolisi)zMetropolis acceptance criterion. Parameters ---------- T : float The "temperature" parameter for the accept or reject criterion. rng : {None, int, `numpy.random.Generator`}, optional Random number generator used for acceptance test. NcZUS:waSU- O [S5Ul[U5Ulg)Nr?inf)rwbetarr)rTrs rrMetropolis.__init__5s' !AvC!G5< %c*rc[R"SS9 URUR- *UR-n[R "[ SU55nSSS5 URR5nWU:=(a$ UR=(d UR(+$!,(df  NX=f)z Assuming the local search underlying res_new was successful: If new energy is lower than old, it will always be accepted. If new is higher than old, there is a chance it will be accepted, less likely for larger differences. ignore)invalidrN) rerrstaterrmathexpminrrr)rrrprodwrands r accept_rejectMetropolis.accept_reject<s[[ *[[7;;./$));DQ&A+xx!DyEgooDW__1DE+ *s AB// B=c6[URX55$)z) f_new and f_old are mandatory in kwargs )boolr)rrrs rrqMetropolis.__call__RsD&&w899r)rrr) r%r&r'r(r)rrrqr*r+rrrr)s +F,:rrseed T) position_num replace_docrr)rfstepwise_factorc ZU S::dU S:a [S5eUS::dUS:a [S5e[R"U5n[U 5n Uc [ 5n[ [ RRU40UD6nUb<[U5(d [S5e[US5(a [XiU UU S9nOUnO[XLS9n[UU U UU S9n/nUb[U5(d [S 5eU/n[X`_ for databases of molecular systems that have been optimized primarily using basin-hopping. This database includes minimization problems exceeding 300 degrees of freedom. See the free software program `GMIN `_ for a Fortran implementation of basin-hopping. This implementation has many variations of the procedure described above, including more advanced step taking algorithms and alternate acceptance criterion. For stochastic global optimization there is no way to determine if the true global minimum has actually been found. Instead, as a consistency check, the algorithm can be run from a number of different random starting points to ensure the lowest minimum found in each example has converged to the global minimum. For this reason, `basinhopping` will by default simply run for the number of iterations `niter` and return the lowest minimum found. It is left to the user to ensure that this is in fact the global minimum. Choosing `stepsize`: This is a crucial parameter in `basinhopping` and depends on the problem being solved. The step is chosen uniformly in the region from x0-stepsize to x0+stepsize, in each dimension. Ideally, it should be comparable to the typical separation (in argument values) between local minima of the function being optimized. `basinhopping` will, by default, adjust `stepsize` to find an optimal value, but this may take many iterations. You will get quicker results if you set a sensible initial value for ``stepsize``. Choosing `T`: The parameter `T` is the "temperature" used in the Metropolis criterion. Basinhopping steps are always accepted if ``func(xnew) < func(xold)``. Otherwise, they are accepted with probability:: exp( -(func(xnew) - func(xold)) / T ) So, for best results, `T` should to be comparable to the typical difference (in function values) between local minima. (The height of "walls" between local minima is irrelevant.) If `T` is 0, the algorithm becomes Monotonic Basin-Hopping, in which all steps that increase energy are rejected. .. versionadded:: 0.12.0 References ---------- .. [1] Wales, David J. 2003, Energy Landscapes, Cambridge University Press, Cambridge, UK. .. [2] Wales, D J, and Doye J P K, Global Optimization by Basin-Hopping and the Lowest Energy Structures of Lennard-Jones Clusters Containing up to 110 Atoms. Journal of Physical Chemistry A, 1997, 101, 5111. .. [3] Li, Z. and Scheraga, H. A., Monte Carlo-minimization approach to the multiple-minima problem in protein folding, Proc. Natl. Acad. Sci. USA, 1987, 84, 6611. .. [4] Wales, D. J. and Scheraga, H. A., Global optimization of clusters, crystals, and biomolecules, Science, 1999, 285, 1368. .. [5] Olson, B., Hashmi, I., Molloy, K., and Shehu1, A., Basin Hopping as a General and Versatile Optimization Framework for the Characterization of Biological Macromolecules, Advances in Artificial Intelligence, Volume 2012 (2012), Article ID 674832, :doi:`10.1155/2012/674832` Examples -------- The following example is a 1-D minimization problem, with many local minima superimposed on a parabola. >>> import numpy as np >>> from scipy.optimize import basinhopping >>> func = lambda x: np.cos(14.5 * x - 0.3) + (x + 0.2) * x >>> x0 = [1.] Basinhopping, internally, uses a local minimization algorithm. We will use the parameter `minimizer_kwargs` to tell basinhopping which algorithm to use and how to set up that minimizer. This parameter will be passed to `scipy.optimize.minimize`. >>> minimizer_kwargs = {"method": "BFGS"} >>> ret = basinhopping(func, x0, minimizer_kwargs=minimizer_kwargs, ... niter=200) >>> # the global minimum is: >>> ret.x, ret.fun -0.1951, -1.0009 Next consider a 2-D minimization problem. Also, this time, we will use gradient information to significantly speed up the search. >>> def func2d(x): ... f = np.cos(14.5 * x[0] - 0.3) + (x[1] + 0.2) * x[1] + (x[0] + ... 0.2) * x[0] ... df = np.zeros(2) ... df[0] = -14.5 * np.sin(14.5 * x[0] - 0.3) + 2. * x[0] + 0.2 ... df[1] = 2. * x[1] + 0.2 ... return f, df We'll also use a different local minimization algorithm. Also, we must tell the minimizer that our function returns both energy and gradient (Jacobian). >>> minimizer_kwargs = {"method":"L-BFGS-B", "jac":True} >>> x0 = [1.0, 1.0] >>> ret = basinhopping(func2d, x0, minimizer_kwargs=minimizer_kwargs, ... niter=200) >>> print("global minimum: x = [%.4f, %.4f], f(x) = %.4f" % (ret.x[0], ... ret.x[1], ... ret.fun)) global minimum: x = [-0.1951, -0.1000], f(x) = -1.0109 Here is an example using a custom step-taking routine. Imagine you want the first coordinate to take larger steps than the rest of the coordinates. This can be implemented like so: >>> class MyTakeStep: ... def __init__(self, stepsize=0.5): ... self.stepsize = stepsize ... self.rng = np.random.default_rng() ... def __call__(self, x): ... s = self.stepsize ... x[0] += self.rng.uniform(-2.*s, 2.*s) ... x[1:] += self.rng.uniform(-s, s, x[1:].shape) ... return x Since ``MyTakeStep.stepsize`` exists basinhopping will adjust the magnitude of `stepsize` to optimize the search. We'll use the same 2-D function as before >>> mytakestep = MyTakeStep() >>> ret = basinhopping(func2d, x0, minimizer_kwargs=minimizer_kwargs, ... niter=200, take_step=mytakestep) >>> print("global minimum: x = [%.4f, %.4f], f(x) = %.4f" % (ret.x[0], ... ret.x[1], ... ret.fun)) global minimum: x = [-0.1951, -0.1000], f(x) = -1.0109 Now, let's do an example using a custom callback function which prints the value of every minimum found >>> def print_fun(x, f, accepted): ... print("at minimum %.4f accepted %d" % (f, int(accepted))) We'll run it for only 10 basinhopping steps this time. >>> rng = np.random.default_rng() >>> ret = basinhopping(func2d, x0, minimizer_kwargs=minimizer_kwargs, ... niter=10, callback=print_fun, rng=rng) at minimum 0.4159 accepted 1 at minimum -0.4317 accepted 1 at minimum -1.0109 accepted 1 at minimum -0.9073 accepted 1 at minimum -0.4317 accepted 0 at minimum -0.1021 accepted 1 at minimum -0.7425 accepted 1 at minimum -0.9073 accepted 1 at minimum -0.4317 accepted 0 at minimum -0.7425 accepted 1 at minimum -0.9073 accepted 1 The minimum at -1.0109 is actually the global minimum, found already on the 8th iteration. grz,target_accept_rate has to be in range (0, 1)z)stepwise_factor has to be in range (0, 1)ztake_step must be callablerv)rgrlrhri)rvrzaccept_test must be callable)r)r8T)rrzBrequested number of basinhopping iterations completed successfullyz7callback function requested stop early byreturning Truer0rzsuccess condition satisfied)!rOrarrayrdictrr:r;minimizecallable TypeErrorrCrbrrappendr-rBrrrranger]rZr[rSr=r#lowest_optimization_resultrmessagenitr)rrDniterrrvminimizer_kwargsro accept_testcallbackrgr8 niter_successrrfrwrapped_minimizertake_step_wrappeddisplacer7 metropolisbhcountirr\valr=s rrrYsV R#5#;GHH"2 5DEE "B S !C6()@)@$=+;= ""89 9 9j ) ) 0.& !  !* &xA,X9K4C59; L $$:; ;#} A'J # B3D(t 5B ""$$bjj&7&7&;&;TBHE1 G 5\ H  299booryyAC 01G   E ] "45G #( &&C%'ZZ%:%:%rs C     YW->->-K-K L   YW->->-K-K L N$..'B.T5T5n??D. @ @ -:-:`F>69DHGKE25cE?Er