| Server IP : 217.160.0.135 / Your IP : 216.73.217.85 Web Server : Apache System : Linux www 6.18.52-i1-ampere #1203 SMP Mon Sep 14 18:29:59 CEST 2026 aarch64 User : sws1074145052 ( 1074145052) PHP Version : 8.3.32 Disable Function : NONE MySQL : OFF | cURL : ON | WGET : ON | Perl : ON | Python : OFF | Sudo : OFF | Pkexec : OFF Directory : /usr/lib/python3/dist-packages/scipy/optimize/__pycache__/ |
Upload File : |
�
d�c�t � �� � d Z ddlZddlZddlZddlmZ dgZ G d� d� � Z G d� d� � Z
G d � d
� � Z G d � d � � Z G d
� d� � Z
G d� d� � Z dddd�d�ZdS )z>
basinhopping: The basinhopping global optimization algorithm
� N)�check_random_state� basinhoppingc �* � e Zd ZdZd� Zd� Zd� Zd� ZdS )�Storagez9
Class used to store the lowest energy structure
c �0 � | � |� � d S �N)�_add��self�minress �>/usr/lib/python3/dist-packages/scipy/optimize/_basinhopping.py�__init__zStorage.__init__ s � � � � �&������ c �Z � || _ t j |j � � | j _ d S r )r �np�copy�xr
s r
r z Storage._add s" � � �� �����)�)�� �
�
�
r c �^ � |j | j j k r| � |� � dS dS )NTF)�funr r r
s r
�updatezStorage.update s/ � � �:�� �� '� '� �I�I�f� � � ��4��5r c � � | j S r )r )r s r
�
get_lowestzStorage.get_lowest s
� ��{�r N)�__name__�
__module__� __qualname__�__doc__r r r r � r r
r r sZ � � � � � �� �� � �*� *� *�� � �� � � � r r c �, � e Zd ZdZdd�Zd� Zd� Zd� ZdS ) �BasinHoppingRunnera; This 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.
Fc �� � t j |� � | _ || _ || _ || _ || _ d| _ t j �
� � | _ d| j _ || j � � }|j
s+| j xj dz
c_ | j rt d� � t j |j � � | _ |j | _ | j r t d| j | j fz � � t# |� � | _ t' |d� � r|j | j _ t' |d� � r|j | j _ t' |d� � r|j | j _ d S d S )Nr � �1warning: basinhopping: local minimization failurezbasinhopping step %d: f %g�nfev�njev�nhev)r r r � minimizer� step_taking� accept_tests�disp�nstep�scipy�optimize�OptimizeResult�res�minimization_failures�success�printr �energyr �storage�hasattrr# r$ r% )r �x0r& r' r( r) r s r
r zBasinHoppingRunner.__init__9 s] � ��������"���&��� (����� ���
� �>�0�0�2�2���)*���&� ��4�6�"�"���~� K� �H� *� *�a� /� *� *��y�
K��I�J�J�J�����"�"��� �j�� � �9� L� �.�$�*�d�k�1J�J� K� K� K� �v���� � �6�6� "� "� (� "�K�D�H�M� �6�6� "� "� (� "�K�D�H�M� �6�6� "� "� (� "�K�D�H�M�M�M� (� (r c � � t j | j � � }| � |� � }| � |� � }|j }|j }|j s+| j xj dz
c_ | j rt d� � t |d� � r| j xj |j z
c_ t |d� � r| j xj
|j
z
c_
t |d� � r| j xj |j z
c_ d}| j D ]:} |||| j | j �� � }|dk rd} n|�t# d
� � �|sd }�;t | j d � � r)| j � |||| j | j �� � ||fS )
z�Do one Monte Carlo iteration
Randomly displace the coordinates, minimize, and decide whether
or not to accept the new coordinates.
r! r" r# r$ r% T)�f_new�x_new�f_old�x_oldz force acceptNz7accept_tests must return True, False, or 'force accept'F�report)r r r r' r& r r0 r. r/ r) r1 r4 r# r$ r% r( r2 �
ValueErrorr; )r � x_after_stepr �x_after_quench�energy_after_quench�accept�test�testress r
�_monte_carlo_stepz$BasinHoppingRunner._monte_carlo_step[ s� � � �w�t�v��� ��'�'� �5�5� � � � � �-�-�� ��� $�j���~� K� �H� *� *�a� /� *� *��y�
K��I�J�J�J� �6�6� "� "� )� �H�M�M�V�[� (�M�M� �6�6� "� "� )� �H�M�M�V�[� (�M�M� �6�6� "� "� )� �H�M�M�V�[� (�M�M� ���%�
�
�D��d�!4�N�!%��D�F�<� <� <�G��.�(�(� ����� � � "2� 3� 3� 3� �
� ��� �4�#�X� .� .� 2� � � #� #�F�2E�*8�� �*.�&�
$�
2�
2�
2� �v�~� r c � � | xj dz
c_ d}| � � � \ }}|rD|j | _ t j |j � � | _ | j � |� � }| j r;| �
|j |� � |r t d| j | j fz � � |j | _ |j | _
|| _ |S )z3Do one cycle of the basinhopping algorithm
r! Fz:found new global minimum on step %d with function value %g)r* rC r r2 r r r r3 r r) � print_reportr1 �xtrial� energy_trialr@ )r �new_global_minr@ r s r
� one_cyclez BasinHoppingRunner.one_cycle� s� � �
�
�
�a��
�
� �� �/�/�1�1���� � 9� �*�D�K��W�V�X�&�&�D�F� !�\� 0� 0�� 8� 8�N� �9� ?� � � �f�j�&� 1� 1� 1� �
?�� "�%)�Z���$=�>� ?� ?� ?� �h�� � "�J��� �� � � r c � � | j � � � }t d| j | j |||j fz � � dS )zprint a status updatez>basinhopping step %d: f %g trial_f %g accepted %d lowest_f %gN)r3 r r1 r* r2 r )r rG r@ r s r
rE z BasinHoppingRunner.print_report� sR � �� �(�(�*�*��
� � $�
�D�K� � &��
� 4�4� 5� 5� 5� 5� 5r N)F)r r r r r rC rI rE r r r
r r " sa � � � � � �� �, (� (� (� (�D4 � 4 � 4 �l � � �65� 5� 5� 5� 5r r c �6 � e Zd ZdZ d d�Zd� Zd� Zd � Zd
� Zd S )
�AdaptiveStepsizea�
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
� �?�2 ��������?Tc �v � || _ || _ || _ || _ || _ d| _ d| _ d| _ d S )Nr )�takestep�target_accept_rate�interval�factor�verboser* � nstep_tot�naccept)r rQ � accept_raterS rT rU s r
r zAdaptiveStepsize.__init__� s? � � ��
�"-�� � ��
� �� � �� ���
������ � � r c �, � | � |� � S r )� take_step�r r s r
�__call__zAdaptiveStepsize.__call__� s � ��~�~�a� � � r c �2 � | j j }t | j � � | j z }|| j k r| j xj | j z c_ n| j xj | j z c_ | j r't d|| j | j j |fz � � d S d S )NzOadaptive stepsize: acceptance rate %f target %f new stepsize %g old stepsize %g) rQ �stepsize�floatrW r* rR rT rU r1 )r � old_stepsizerX s r
�_adjust_step_sizez"AdaptiveStepsize._adjust_step_size� s� � ��}�-� ��D�L�)�)�D�J�6� � ��0� 0� 0�
�M� "� "�d�k� 1� "� "� "�
�M� "� "�d�k� 1� "� "� �<� !� � 0�3>��)�4�=�+A� �3 � �
!�
!�
!�
!�
!� !� !r c � � | xj dz
c_ | xj dz
c_ | j | j z dk r| � � � | � |� � S )Nr! r )r* rV rS ra rQ r[ s r
rZ zAdaptiveStepsize.take_step� sY � � �
�
�a��
�
� ���!���� �:��
� %�� *� *� � "� "� $� $� $��}�}�Q� � � r c �. � |r| xj dz
c_ dS dS )z7called by basinhopping to report the result of the stepr! N)rW )r r@ �kwargss r
r; zAdaptiveStepsize.report� s( � � � � �L�L�A� �L�L�L�L� � r N)rM rN rO T) r r r r r r\ ra rZ r; r r r
rL rL � sx � � � � � �� �, GJ� �
�
�
�
�!� !� !�!� !� !� � � � � � � � r rL c � � e Zd ZdZdd�Zd� ZdS )�RandomDisplacementa� Add 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
random_gen : {None, int, `numpy.random.Generator`,
`numpy.random.RandomState`}, optional
If `seed` is None (or `np.random`), the `numpy.random.RandomState`
singleton is used.
If `seed` is an int, a new ``RandomState`` instance is used,
seeded with `seed`.
If `seed` is already a ``Generator`` or ``RandomState`` instance then
that instance is used.
rM Nc �< � || _ t |� � | _ d S r )r^ r �
random_gen)r r^ rh s r
r zRandomDisplacement.__init__ s � � ��
�,�Z�8�8����r c �~ � || j � | j | j t j |� � � � z
}|S r )rh �uniformr^ r �shaper[ s r
r\ zRandomDisplacement.__call__ s: � � �T�_�
$�
$�d�m�^�T�]�%'�X�a�[�[�2� 2� 2���r )rM N�r r r r r r\ r r r
rf rf � sA � � � � � �� �(9� 9� 9� 9�� � � � r rf c � � e Zd ZdZdd�Zd� ZdS )�MinimizerWrapperz8
wrap a minimizer function as a minimizer class
Nc �0 � || _ || _ || _ d S r )r& �funcrd )r r& rp rd s r
r zMinimizerWrapper.__init__ s � �"����� � �� � � r c �h � | j � | j |fi | j ��S | j | j |fi | j ��S r )rp r& rd )r r5 s r
r\ zMinimizerWrapper.__call__ sF � � �9� �!�4�>�"�4�4�� �4�4� 4�!�4�>�$�)�R�?�?�4�;�?�?� ?r r rl r r r
rn rn sF � � � � � �� � � � � �
@� @� @� @� @r rn c �& � e Zd ZdZdd�Zd� Zd� ZdS )�
Metropolisay Metropolis acceptance criterion.
Parameters
----------
T : float
The "temperature" parameter for the accept or reject criterion.
random_gen : {None, int, `numpy.random.Generator`,
`numpy.random.RandomState`}, optional
If `seed` is None (or `np.random`), the `numpy.random.RandomState`
singleton is used.
If `seed` is an int, a new ``RandomState`` instance is used,
seeded with `seed`.
If `seed` is already a ``Generator`` or ``RandomState`` instance then
that instance is used.
Random number generator used for acceptance test.
Nc �l � |dk rd|z nt d� � | _ t |� � | _ d S )Nr � �?�inf)r_ �betar rh )r �Trh s r
r zMetropolis.__init__: s4 � � !�A�v�v�C�!�G�G�5��<�<�� �,�Z�8�8����r c � � t j d�� � 5 ||z
| j z }t j t d|� � � � }ddd� � n # 1 swxY w Y | j � � � }||k S )z�
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)�invalidr N)r �errstaterw �math�exp�minrh rj )r �
energy_new�
energy_old�prod�w�rands r
�
accept_rejectzMetropolis.accept_rejectA s� � � �[��
*�
*�
*�
'�
'� �*�,�-�� �9�D����Q�� � �&�&�A�
'�
'�
'�
'�
'�
'�
'�
'�
'�
'�
'����
'�
'�
'�
'� ��&�&�(�(���D�y�s �1A�A�Ac �` � t | � |d |d � � � � S )z9
f_new and f_old are mandatory in kwargs
r7 r9 )�boolr� )r rd s r
r\ zMetropolis.__call__V s5 � � �D�&�&�v�g���7�O�%� %� &� &� &r r )r r r r r r� r\ r r r
rs rs & sP � � � � � �� �&9� 9� 9� 9�� � �*&� &� &� &� &r rs �d ru rM rN FrO )rR �stepwise_factorc
� � |
dk s|
dk rt d� � �|dk s|dk rt d� � �t j |� � }t | � � }|�t � � }t t j j | fi |��}|�Ft |� � st d� � �t |d� � rt || |
||
�� � }n(|}n%t ||� � � }t || |
||
�� � }g }|�!t |� � st d
� � �|g}t ||� � � }|� |� � | �|d z } t! |||||
�
� � }t |� � r+ ||j j j |j j j d� � d\ }}dg}t+ |� � D ]_}|� � � }t |� � r% ||j |j |j � � }|�|rdg} n|dz
}|rd}�T|| k rdg} n�`|j }|j � � � |_ t j |j j � � |_ |j j |_ ||_ |dz |_ |j j |_ |S )aH7 Find the global minimum of a function using the basin-hopping algorithm.
Basin-hopping is a two-phase method that combines a global stepping
algorithm with local minimization at each step. Designed to mimic
the natural process of energy minimization of clusters of atoms, it works
well for similar problems with "funnel-like, but rugged" energy landscapes
[5]_.
As the step-taking, step acceptance, and minimization methods are all
customizable, this function can also be used to implement other two-phase
methods.
Parameters
----------
func : callable ``f(x, *args)``
Function to be optimized. ``args`` can be passed as an optional item
in the dict `minimizer_kwargs`
x0 : array_like
Initial guess.
niter : integer, optional
The number of basin-hopping iterations. There will be a total of
``niter + 1`` runs of the local minimizer.
T : float, optional
The "temperature" parameter for the acceptance or rejection criterion.
Higher "temperatures" mean that larger jumps in function value will be
accepted. For best results `T` should be comparable to the
separation (in function value) between local minima.
stepsize : float, optional
Maximum step size for use in the random displacement.
minimizer_kwargs : dict, optional
Extra keyword arguments to be passed to the local minimizer
`scipy.optimize.minimize` Some important options could be:
method : str
The minimization method (e.g. ``"L-BFGS-B"``)
args : tuple
Extra arguments passed to the objective function (`func`) and
its derivatives (Jacobian, Hessian).
take_step : callable ``take_step(x)``, optional
Replace the default step-taking routine with this routine. The default
step-taking routine is a random displacement of the coordinates, but
other step-taking algorithms may be better for some systems.
`take_step` can optionally have the attribute ``take_step.stepsize``.
If this attribute exists, then `basinhopping` will adjust
``take_step.stepsize`` in order to try to optimize the global minimum
search.
accept_test : callable, ``accept_test(f_new=f_new, x_new=x_new, f_old=fold, x_old=x_old)``, optional
Define a test which will be used to judge whether to accept the
step. This will be used in addition to the Metropolis test based on
"temperature" `T`. The acceptable return values are True,
False, or ``"force accept"``. If any of the tests return False
then the step is rejected. If the latter, 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.
callback : callable, ``callback(x, f, accept)``, optional
A callback function which will be called for all minima found. ``x``
and ``f`` are the coordinates and function value of the trial minimum,
and ``accept`` is whether that minimum was accepted. This can
be used, for example, to save the lowest N minima found. Also,
`callback` can be used to specify a user defined stop criterion by
optionally returning True to stop the `basinhopping` routine.
interval : integer, optional
interval for how often to update the `stepsize`
disp : bool, optional
Set to True to print status messages
niter_success : integer, optional
Stop the run if the global minimum candidate remains the same for this
number of iterations.
seed : {None, int, `numpy.random.Generator`, `numpy.random.RandomState`}, optional
If `seed` is None (or `np.random`), the `numpy.random.RandomState`
singleton is used.
If `seed` is an int, a new ``RandomState`` instance is used,
seeded with `seed`.
If `seed` is already a ``Generator`` or ``RandomState`` instance then
that instance is used.
Specify `seed` for repeatable minimizations. The random numbers
generated with this seed only affect the default Metropolis
`accept_test` and the default `take_step`. If you supply your own
`take_step` and `accept_test`, and these functions use random
number generation, then those functions are responsible for the state
of their random number generator.
target_accept_rate : float, optional
The target acceptance rate that is used to adjust the `stepsize`.
If the current acceptance rate is greater than the target,
then the `stepsize` is increased. Otherwise, it is decreased.
Range is (0, 1). Default is 0.5.
.. versionadded:: 1.8.0
stepwise_factor : float, optional
The `stepsize` is multiplied or divided by this stepwise factor upon
each update. Range is (0, 1). Default is 0.9.
.. versionadded:: 1.8.0
Returns
-------
res : OptimizeResult
The optimization result represented as a `OptimizeResult` object.
Important attributes are: ``x`` the solution array, ``fun`` the value
of the function at the solution, and ``message`` which describes the
cause of the termination. The ``OptimizeResult`` object returned by the
selected minimizer at the lowest minimum is also contained within this
object and can be accessed through the ``lowest_optimization_result``
attribute. See `OptimizeResult` for a description of other attributes.
See Also
--------
minimize :
The local minimization function called once for each basinhopping step.
`minimizer_kwargs` is passed to this routine.
Notes
-----
Basin-hopping is a stochastic algorithm which attempts to find the global
minimum of a smooth scalar function of one or more variables [1]_ [2]_ [3]_
[4]_. The algorithm in its current form was described by David Wales and
Jonathan Doye [2]_ http://www-wales.ch.cam.ac.uk/.
The algorithm is iterative with each cycle composed of the following
features
1) random perturbation of the coordinates
2) local minimization
3) accept or reject the new coordinates based on the minimized function
value
The acceptance test used here is the Metropolis criterion of standard Monte
Carlo algorithms, although there are many other possibilities [3]_.
This global minimization method has been shown to be extremely efficient
for a wide variety of problems in physics and chemistry. It is
particularly useful when the function has many minima separated by large
barriers. See the `Cambridge Cluster Database
<https://www-wales.ch.cam.ac.uk/CCD.html>`_ 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 <https://www-wales.ch.cam.ac.uk/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)
>>> print("global minimum: x = %.4f, f(x) = %.4f" % (ret.x, ret.fun))
global minimum: x = -0.1951, f(x) = -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, seed=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.
g ru z,target_accept_rate has to be in range (0, 1)z)stepwise_factor has to be in range (0, 1)Nztake_step must be callabler^ )rS rX rT rU )r^ rh z accept_test must be callable)rh � )r) T)r r zBrequested number of basinhopping iterations completed successfullyz7callback function requested stop early byreturning Truer! r zsuccess condition satisfied)!r< r �arrayr �dictrn r+ r, �minimize�callable� TypeErrorr4 rL rf rs �appendr r3 r r r �rangerI rF rG r@ r. r �lowest_optimization_resultr �message�nitr0 ) rp r5 �niterrx r^ �minimizer_kwargsrZ � accept_test�callbackrS r) �
niter_success�seedrR r� �rng�wrapped_minimizer�take_step_wrapped�displacer( �
metropolis�bh�count�ir� rH �valr. s r
r r ^ s" � �X �R� � �#5��#;�#;��G�H�H�H��"� � ��2� 5� 5��D�E�E�E� ��"� � �B� �T�
"�
"�C� � � �6�6��(�� �)@�$� =� =�+;�=� =�� � �� �"�"� :�� 8�9�9� 9� �9�j� )� )� *� 0��H� .�&� � ! � ! � ! � � � !*� � � &�x�C�H�H�H�� ,�X��9K�4C�59� ;� ;� ;�� �L�� �� �$�$� <�� :�;�;� ;�#�}� � �A�#�.�.�.�J����
�#�#�#�� � �� �
� �B� 1�3D� (�t�
5�
5�
5�B�
���� C�����"�$�b�j�&7�&;�T�B�B�B� �H�E�1� � �G�
�5�\�\� � ��� � � � �� �H� � � ��(�2�9�b�o�r�y�A�A�C���� � 0� 1�G��E�
��
�� � ��E�E�
�]�
"�
"�4�5�G� �E� #�
�&�C�%'�Z�%:�%:�%<�%<�C�"� �G�C�2�4� 5� 5�C�E��,�0�C�G��C�K��!�e�C�G��0�8�C�K� �Jr ) r� ru rM NNNNrN FNN)r �numpyr r} �scipy.optimizer+ �scipy._lib._utilr �__all__r r rL rf rn rs r r r r
�<module>r� s� ��� � � � � � � � � � � � � � /� /� /� /� /� /� �
��� � � � � � � �,O5� O5� O5� O5� O5� O5� O5� O5�d@ � @ � @ � @ � @ � @ � @ � @ �F � � � � � � � �>
@�
@�
@�
@�
@�
@�
@�
@� 5&� 5&� 5&� 5&� 5&� 5&� 5&� 5&�p 7:�DH�GK��G� 36�s�G� G� G� G� G� G� Gr