{ "__type": "IngestedDoc", "__tag": 4010, "_content": { "Notes": { "__type": "Section", "__tag": 4015, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "Basin-hopping is a stochastic algorithm which attempts to find the global minimum of a smooth scalar function of one or more variables " }, { "__type": "FootnoteReference", "__tag": 4066, "label": "1" }, { "__type": "Text", "__tag": 4046, "value": " " }, { "__type": "FootnoteReference", "__tag": 4066, "label": "2" }, { "__type": "Text", "__tag": 4046, "value": " " }, { "__type": "FootnoteReference", "__tag": 4066, "label": "3" }, { "__type": "Text", "__tag": 4046, "value": " " }, { "__type": "FootnoteReference", "__tag": 4066, "label": "4" }, { "__type": "Text", "__tag": 4046, "value": ". The algorithm in its current form was described by David Wales and Jonathan Doye " }, { "__type": "FootnoteReference", "__tag": 4066, "label": "2" }, { "__type": "Text", "__tag": 4046, "value": " http://www-wales.ch.cam.ac.uk/." } ] }, { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "The algorithm is iterative with each cycle composed of the following features" } ] }, { "__type": "BulletList", "__tag": 4053, "ordered": true, "start": 1, "children": [ { "__type": "ListItem", "__tag": 4054, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "random perturbation of the coordinates" } ] } ] }, { "__type": "ListItem", "__tag": 4054, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "local minimization" } ] } ] }, { "__type": "ListItem", "__tag": 4054, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "accept or reject the new coordinates based on the minimized function value" } ] } ] } ] }, { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "The acceptance test used here is the Metropolis criterion of standard Monte Carlo algorithms, although there are many other possibilities " }, { "__type": "FootnoteReference", "__tag": 4066, "label": "3" }, { "__type": "Text", "__tag": 4046, "value": "." } ] }, { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "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 " }, { "__type": "Link", "__tag": 4049, "children": [ { "__type": "Text", "__tag": 4046, "value": "Cambridge Cluster Database" } ], "url": "https://www-wales.ch.cam.ac.uk/CCD.html", "title": "" }, { "__type": "Text", "__tag": 4046, "value": " for databases of molecular systems that have been optimized primarily using basin-hopping. This database includes minimization problems exceeding 300 degrees of freedom." } ] }, { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "See the free software program " }, { "__type": "Link", "__tag": 4049, "children": [ { "__type": "Text", "__tag": 4046, "value": "GMIN" } ], "url": "https://www-wales.ch.cam.ac.uk/GMIN", "title": "" }, { "__type": "Text", "__tag": 4046, "value": " 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." } ] }, { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "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, " }, { "__type": "CrossRef", "__tag": 4002, "value": "basinhopping", "reference": { "__type": "LocalRef", "__tag": 4022, "kind": "module", "path": "scipy.optimize._basinhopping:basinhopping" }, "kind": "module" }, { "__type": "Text", "__tag": 4046, "value": " will by default simply run for the number of iterations " }, { "__type": "ParamRef", "__tag": 4071, "name": "niter" }, { "__type": "Text", "__tag": 4046, "value": " and return the lowest minimum found. It is left to the user to ensure that this is in fact the global minimum." } ] }, { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "Choosing " }, { "__type": "ParamRef", "__tag": 4071, "name": "stepsize" }, { "__type": "Text", "__tag": 4046, "value": ": This is a crucial parameter in " }, { "__type": "CrossRef", "__tag": 4002, "value": "basinhopping", "reference": { "__type": "LocalRef", "__tag": 4022, "kind": "module", "path": "scipy.optimize._basinhopping:basinhopping" }, "kind": "module" }, { "__type": "Text", "__tag": 4046, "value": " 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. " }, { "__type": "CrossRef", "__tag": 4002, "value": "basinhopping", "reference": { "__type": "LocalRef", "__tag": 4022, "kind": "module", "path": "scipy.optimize._basinhopping:basinhopping" }, "kind": "module" }, { "__type": "Text", "__tag": 4046, "value": " will, by default, adjust " }, { "__type": "ParamRef", "__tag": 4071, "name": "stepsize" }, { "__type": "Text", "__tag": 4046, "value": " to find an optimal value, but this may take many iterations. You will get quicker results if you set a sensible initial value for " }, { "__type": "InlineCode", "__tag": 4051, "value": "stepsize" }, { "__type": "Text", "__tag": 4046, "value": "." } ] }, { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "Choosing " }, { "__type": "ParamRef", "__tag": 4071, "name": "T" }, { "__type": "Text", "__tag": 4046, "value": ": The parameter " }, { "__type": "ParamRef", "__tag": 4071, "name": "T" }, { "__type": "Text", "__tag": 4046, "value": " is the \"temperature\" used in the Metropolis criterion. Basinhopping steps are always accepted if " }, { "__type": "InlineCode", "__tag": 4051, "value": "func(xnew) < func(xold)" }, { "__type": "Text", "__tag": 4046, "value": ". Otherwise, they are accepted with probability " } ] }, { "__type": "Code", "__tag": 4050, "value": "exp( -(func(xnew) - func(xold)) / T )", "execution_status": null }, { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "So, for best results, " }, { "__type": "ParamRef", "__tag": 4071, "name": "T" }, { "__type": "Text", "__tag": 4046, "value": " should to be comparable to the typical difference (in function values) between local minima. (The height of \"walls\" between local minima is irrelevant.)" } ] }, { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "If " }, { "__type": "ParamRef", "__tag": 4071, "name": "T" }, { "__type": "Text", "__tag": 4046, "value": " is 0, the algorithm becomes Monotonic Basin-Hopping, in which all steps that increase energy are rejected." } ] }, { "__type": "Admonition", "__tag": 4056, "kind": "versionadded", "base_type": "neutral", "children": [ { "__type": "AdmonitionTitle", "__tag": 4055, "children": [ { "__type": "Text", "__tag": 4046, "value": "versionadded 0.12.0" } ] } ] } ], "title": [], "level": 0, "target": null }, "Warns": { "__type": "Section", "__tag": 4015, "children": [], "title": [], "level": 0, "target": null }, "Raises": { "__type": "Section", "__tag": 4015, "children": [], "title": [], "level": 0, "target": null }, "Yields": { "__type": "Section", "__tag": 4015, "children": [], "title": [], "level": 0, "target": null }, "Methods": { "__type": "Section", "__tag": 4015, "children": [], "title": [], "level": 0, "target": null }, "Returns": { "__type": "Section", "__tag": 4015, "children": [ { "__type": "Parameters", "__tag": 4026, "children": [ { "__type": "DocParam", "__tag": 4016, "name": "res", "annotation": "OptimizeResult", "desc": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "The optimization result represented as a " }, { "__type": "CrossRef", "__tag": 4002, "value": "OptimizeResult", "reference": { "__type": "LocalRef", "__tag": 4022, "kind": "module", "path": "scipy.optimize._optimize:OptimizeResult" }, "kind": "module" }, { "__type": "Text", "__tag": 4046, "value": " object. Important attributes are: " }, { "__type": "InlineCode", "__tag": 4051, "value": "x" }, { "__type": "Text", "__tag": 4046, "value": " the solution array, " }, { "__type": "InlineCode", "__tag": 4051, "value": "fun" }, { "__type": "Text", "__tag": 4046, "value": " the value of the function at the solution, and " }, { "__type": "InlineCode", "__tag": 4051, "value": "message" }, { "__type": "Text", "__tag": 4046, "value": " which describes the cause of the termination. The " }, { "__type": "InlineCode", "__tag": 4051, "value": "OptimizeResult" }, { "__type": "Text", "__tag": 4046, "value": " object returned by the selected minimizer at the lowest minimum is also contained within this object and can be accessed through the " }, { "__type": "InlineCode", "__tag": 4051, "value": "lowest_optimization_result" }, { "__type": "Text", "__tag": 4046, "value": " attribute. " }, { "__type": "InlineCode", "__tag": 4051, "value": "lowest_optimization_result" }, { "__type": "Text", "__tag": 4046, "value": " will only be updated if a local minimization was successful. See " }, { "__type": "CrossRef", "__tag": 4002, "value": "OptimizeResult", "reference": { "__type": "LocalRef", "__tag": 4022, "kind": "module", "path": "scipy.optimize._optimize:OptimizeResult" }, "kind": "module" }, { "__type": "Text", "__tag": 4046, "value": " for a description of other attributes." } ] } ] } ] } ], "title": [], "level": 0, "target": null }, "Summary": { "__type": "Section", "__tag": 4015, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "Find the global minimum of a function using the basin-hopping algorithm." } ] } ], "title": [], "level": 0, "target": null }, "Receives": { "__type": "Section", "__tag": 4015, "children": [], "title": [], "level": 0, "target": null }, "Warnings": { "__type": "Section", "__tag": 4015, "children": [], "title": [], "level": 0, "target": null }, "Attributes": { "__type": "Section", "__tag": 4015, "children": [], "title": [], "level": 0, "target": null }, "Parameters": { "__type": "Section", "__tag": 4015, "children": [ { "__type": "Parameters", "__tag": 4026, "children": [ { "__type": "DocParam", "__tag": 4016, "name": "func", "annotation": "callable ``f(x, *args)``", "desc": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "Function to be optimized. " }, { "__type": "InlineCode", "__tag": 4051, "value": "args" }, { "__type": "Text", "__tag": 4046, "value": " can be passed as an optional item in the dict " }, { "__type": "ParamRef", "__tag": 4071, "name": "minimizer_kwargs" } ] } ] }, { "__type": "DocParam", "__tag": 4016, "name": "x0", "annotation": "array_like", "desc": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "Initial guess." } ] } ] }, { "__type": "DocParam", "__tag": 4016, "name": "niter", "annotation": "integer, optional", "desc": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "The number of basin-hopping iterations. There will be a total of " }, { "__type": "InlineCode", "__tag": 4051, "value": "niter + 1" }, { "__type": "Text", "__tag": 4046, "value": " runs of the local minimizer." } ] } ] }, { "__type": "DocParam", "__tag": 4016, "name": "T", "annotation": "float, optional", "desc": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "The \"temperature\" parameter for the acceptance or rejection criterion. Higher \"temperatures\" mean that larger jumps in function value will be accepted. For best results " }, { "__type": "ParamRef", "__tag": 4071, "name": "T" }, { "__type": "Text", "__tag": 4046, "value": " should be comparable to the separation (in function value) between local minima." } ] } ] }, { "__type": "DocParam", "__tag": 4016, "name": "stepsize", "annotation": "float, optional", "desc": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "Maximum step size for use in the random displacement." } ] } ] }, { "__type": "DocParam", "__tag": 4016, "name": "minimizer_kwargs", "annotation": "dict, optional", "desc": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "Extra keyword arguments to be passed to the local minimizer " }, { "__type": "CrossRef", "__tag": 4002, "value": "scipy.optimize.minimize", "reference": { "__type": "RefInfo", "__tag": 4000, "module": "scipy", "version": "*", "kind": "api", "path": "scipy.optimize._minimize:minimize" }, "kind": "module" }, { "__type": "Text", "__tag": 4046, "value": " Some important options could be:" } ] }, { "__type": "DefList", "__tag": 4033, "children": [ { "__type": "DefListItem", "__tag": 4037, "dt": { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "method" } ] }, "dd": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "method" } ] } ] }, { "__type": "DefListItem", "__tag": 4037, "dt": { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "args" } ] }, "dd": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "args" } ] } ] } ] } ] }, { "__type": "DocParam", "__tag": 4016, "name": "take_step", "annotation": "callable ``take_step(x)``, optional", "desc": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "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. " }, { "__type": "ParamRef", "__tag": 4071, "name": "take_step" }, { "__type": "Text", "__tag": 4046, "value": " can optionally have the attribute " }, { "__type": "InlineCode", "__tag": 4051, "value": "take_step.stepsize" }, { "__type": "Text", "__tag": 4046, "value": ". If this attribute exists, then " }, { "__type": "CrossRef", "__tag": 4002, "value": "basinhopping", "reference": { "__type": "LocalRef", "__tag": 4022, "kind": "module", "path": "scipy.optimize._basinhopping:basinhopping" }, "kind": "module" }, { "__type": "Text", "__tag": 4046, "value": " will adjust " }, { "__type": "InlineCode", "__tag": 4051, "value": "take_step.stepsize" }, { "__type": "Text", "__tag": 4046, "value": " in order to try to optimize the global minimum search." } ] } ] }, { "__type": "DocParam", "__tag": 4016, "name": "accept_test", "annotation": "callable, ``accept_test(f_new=f_new, x_new=x_new, f_old=fold, x_old=x_old)``, optional", "desc": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "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\" " }, { "__type": "ParamRef", "__tag": 4071, "name": "T" }, { "__type": "Text", "__tag": 4046, "value": ". The acceptable return values are True, False, or " }, { "__type": "InlineCode", "__tag": 4051, "value": "\"force accept\"" }, { "__type": "Text", "__tag": 4046, "value": ". 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 " }, { "__type": "CrossRef", "__tag": 4002, "value": "basinhopping", "reference": { "__type": "LocalRef", "__tag": 4022, "kind": "module", "path": "scipy.optimize._basinhopping:basinhopping" }, "kind": "module" }, { "__type": "Text", "__tag": 4046, "value": " is trapped in." } ] } ] }, { "__type": "DocParam", "__tag": 4016, "name": "callback", "annotation": "callable, ``callback(x, f, accept)``, optional", "desc": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "A callback function which will be called for all minima found. " }, { "__type": "InlineCode", "__tag": 4051, "value": "x" }, { "__type": "Text", "__tag": 4046, "value": " and " }, { "__type": "InlineCode", "__tag": 4051, "value": "f" }, { "__type": "Text", "__tag": 4046, "value": " are the coordinates and function value of the trial minimum, and " }, { "__type": "InlineCode", "__tag": 4051, "value": "accept" }, { "__type": "Text", "__tag": 4046, "value": " is whether that minimum was accepted. This can be used, for example, to save the lowest N minima found. Also, " }, { "__type": "ParamRef", "__tag": 4071, "name": "callback" }, { "__type": "Text", "__tag": 4046, "value": " can be used to specify a user defined stop criterion by optionally returning True to stop the " }, { "__type": "CrossRef", "__tag": 4002, "value": "basinhopping", "reference": { "__type": "LocalRef", "__tag": 4022, "kind": "module", "path": "scipy.optimize._basinhopping:basinhopping" }, "kind": "module" }, { "__type": "Text", "__tag": 4046, "value": " routine." } ] } ] }, { "__type": "DocParam", "__tag": 4016, "name": "interval", "annotation": "integer, optional", "desc": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "interval for how often to update the " }, { "__type": "ParamRef", "__tag": 4071, "name": "stepsize" } ] } ] }, { "__type": "DocParam", "__tag": 4016, "name": "disp", "annotation": "bool, optional", "desc": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "Set to True to print status messages" } ] } ] }, { "__type": "DocParam", "__tag": 4016, "name": "niter_success", "annotation": "integer, optional", "desc": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "Stop the run if the global minimum candidate remains the same for this number of iterations." } ] } ] }, { "__type": "DocParam", "__tag": 4016, "name": "rng", "annotation": "{None, int, `numpy.random.Generator`}, optional", "desc": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "If " }, { "__type": "ParamRef", "__tag": 4071, "name": "rng" }, { "__type": "Text", "__tag": 4046, "value": " is passed by keyword, types other than " }, { "__type": "CrossRef", "__tag": 4002, "value": "numpy.random.Generator", "reference": { "__type": "RefInfo", "__tag": 4000, "module": "numpy", "version": "*", "kind": "api", "path": "numpy.random._generator:Generator" }, "kind": "module" }, { "__type": "Text", "__tag": 4046, "value": " are passed to " }, { "__type": "CrossRef", "__tag": 4002, "value": "numpy.random.default_rng", "reference": { "__type": "RefInfo", "__tag": 4000, "module": "numpy", "version": "*", "kind": "api", "path": "numpy.random:default_rng" }, "kind": "module" }, { "__type": "Text", "__tag": 4046, "value": " to instantiate a " }, { "__type": "InlineCode", "__tag": 4051, "value": "Generator" }, { "__type": "Text", "__tag": 4046, "value": ". If " }, { "__type": "ParamRef", "__tag": 4071, "name": "rng" }, { "__type": "Text", "__tag": 4046, "value": " is already a " }, { "__type": "InlineCode", "__tag": 4051, "value": "Generator" }, { "__type": "Text", "__tag": 4046, "value": " instance, then the provided instance is used. Specify " }, { "__type": "ParamRef", "__tag": 4071, "name": "rng" }, { "__type": "Text", "__tag": 4046, "value": " for repeatable function behavior." } ] }, { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "If this argument is passed by position or " }, { "__type": "ParamRef", "__tag": 4071, "name": "seed" }, { "__type": "Text", "__tag": 4046, "value": " is passed by keyword, legacy behavior for the argument " }, { "__type": "ParamRef", "__tag": 4071, "name": "seed" }, { "__type": "Text", "__tag": 4046, "value": " applies:" } ] }, { "__type": "BulletList", "__tag": 4053, "ordered": false, "start": 1, "children": [ { "__type": "ListItem", "__tag": 4054, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "If " }, { "__type": "ParamRef", "__tag": 4071, "name": "seed" }, { "__type": "Text", "__tag": 4046, "value": " is None (or " }, { "__type": "CrossRef", "__tag": 4002, "value": "numpy.random", "reference": { "__type": "RefInfo", "__tag": 4000, "module": "numpy", "version": "*", "kind": "api", "path": "numpy.random" }, "kind": "module" }, { "__type": "Text", "__tag": 4046, "value": "), the " }, { "__type": "CrossRef", "__tag": 4002, "value": "numpy.random.RandomState", "reference": { "__type": "RefInfo", "__tag": 4000, "module": "numpy", "version": "*", "kind": "api", "path": "numpy.random.mtrand:RandomState" }, "kind": "module" }, { "__type": "Text", "__tag": 4046, "value": " singleton is used." } ] } ] }, { "__type": "ListItem", "__tag": 4054, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "If " }, { "__type": "ParamRef", "__tag": 4071, "name": "seed" }, { "__type": "Text", "__tag": 4046, "value": " is an int, a new " }, { "__type": "InlineCode", "__tag": 4051, "value": "RandomState" }, { "__type": "Text", "__tag": 4046, "value": " instance is used, seeded with " }, { "__type": "ParamRef", "__tag": 4071, "name": "seed" }, { "__type": "Text", "__tag": 4046, "value": "." } ] } ] }, { "__type": "ListItem", "__tag": 4054, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "If " }, { "__type": "ParamRef", "__tag": 4071, "name": "seed" }, { "__type": "Text", "__tag": 4046, "value": " is already a " }, { "__type": "InlineCode", "__tag": 4051, "value": "Generator" }, { "__type": "Text", "__tag": 4046, "value": " or " }, { "__type": "InlineCode", "__tag": 4051, "value": "RandomState" }, { "__type": "Text", "__tag": 4046, "value": " instance then that instance is used." } ] } ] } ] }, { "__type": "Admonition", "__tag": 4056, "kind": "versionchanged", "base_type": "neutral", "children": [ { "__type": "AdmonitionTitle", "__tag": 4055, "children": [ { "__type": "Text", "__tag": 4046, "value": "versionchanged 1.15.0" } ] }, { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "As part of the " }, { "__type": "Link", "__tag": 4049, "children": [ { "__type": "Text", "__tag": 4046, "value": "SPEC-007" } ], "url": "https://scientific-python.org/specs/spec-0007/", "title": "" }, { "__type": "Text", "__tag": 4046, "value": " transition from use of " }, { "__type": "CrossRef", "__tag": 4002, "value": "numpy.random.RandomState", "reference": { "__type": "RefInfo", "__tag": 4000, "module": "numpy", "version": "*", "kind": "api", "path": "numpy.random.mtrand:RandomState" }, "kind": "module" }, { "__type": "Text", "__tag": 4046, "value": " to " }, { "__type": "CrossRef", "__tag": 4002, "value": "numpy.random.Generator", "reference": { "__type": "RefInfo", "__tag": 4000, "module": "numpy", "version": "*", "kind": "api", "path": "numpy.random._generator:Generator" }, "kind": "module" }, { "__type": "Text", "__tag": 4046, "value": ", this keyword was changed from " }, { "__type": "ParamRef", "__tag": 4071, "name": "seed" }, { "__type": "Text", "__tag": 4046, "value": " to " }, { "__type": "ParamRef", "__tag": 4071, "name": "rng" }, { "__type": "Text", "__tag": 4046, "value": ". For an interim period, both keywords will continue to work, although only one may be specified at a time. After the interim period, function calls using the " }, { "__type": "ParamRef", "__tag": 4071, "name": "seed" }, { "__type": "Text", "__tag": 4046, "value": " keyword will emit warnings. The behavior of both " }, { "__type": "ParamRef", "__tag": 4071, "name": "seed" }, { "__type": "Text", "__tag": 4046, "value": " and " }, { "__type": "ParamRef", "__tag": 4071, "name": "rng" }, { "__type": "Text", "__tag": 4046, "value": " are outlined above, but only the " }, { "__type": "ParamRef", "__tag": 4071, "name": "rng" }, { "__type": "Text", "__tag": 4046, "value": " keyword should be used in new code." } ] } ] }, { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "The random numbers generated only affect the default Metropolis " }, { "__type": "ParamRef", "__tag": 4071, "name": "accept_test" }, { "__type": "Text", "__tag": 4046, "value": " and the default " }, { "__type": "ParamRef", "__tag": 4071, "name": "take_step" }, { "__type": "Text", "__tag": 4046, "value": ". If you supply your own " }, { "__type": "ParamRef", "__tag": 4071, "name": "take_step" }, { "__type": "Text", "__tag": 4046, "value": " and " }, { "__type": "ParamRef", "__tag": 4071, "name": "accept_test" }, { "__type": "Text", "__tag": 4046, "value": ", and these functions use random number generation, then those functions are responsible for the state of their random number generator." } ] } ] }, { "__type": "DocParam", "__tag": 4016, "name": "target_accept_rate", "annotation": "float, optional", "desc": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "The target acceptance rate that is used to adjust the " }, { "__type": "ParamRef", "__tag": 4071, "name": "stepsize" }, { "__type": "Text", "__tag": 4046, "value": ". If the current acceptance rate is greater than the target, then the " }, { "__type": "ParamRef", "__tag": 4071, "name": "stepsize" }, { "__type": "Text", "__tag": 4046, "value": " is increased. Otherwise, it is decreased. Range is (0, 1). Default is 0.5." } ] }, { "__type": "Admonition", "__tag": 4056, "kind": "versionadded", "base_type": "neutral", "children": [ { "__type": "AdmonitionTitle", "__tag": 4055, "children": [ { "__type": "Text", "__tag": 4046, "value": "versionadded 1.8.0" } ] } ] } ] }, { "__type": "DocParam", "__tag": 4016, "name": "stepwise_factor", "annotation": "float, optional", "desc": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "The " }, { "__type": "ParamRef", "__tag": 4071, "name": "stepsize" }, { "__type": "Text", "__tag": 4046, "value": " is multiplied or divided by this stepwise factor upon each update. Range is (0, 1). Default is 0.9." } ] }, { "__type": "Admonition", "__tag": 4056, "kind": "versionadded", "base_type": "neutral", "children": [ { "__type": "AdmonitionTitle", "__tag": 4055, "children": [ { "__type": "Text", "__tag": 4046, "value": "versionadded 1.8.0" } ] } ] } ] } ] } ], "title": [], "level": 0, "target": null }, "Extended Summary": { "__type": "Section", "__tag": 4015, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "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 " }, { "__type": "FootnoteReference", "__tag": 4066, "label": "5" }, { "__type": "Text", "__tag": 4046, "value": "." } ] }, { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "As the step-taking, step acceptance, and minimization methods are all customizable, this function can also be used to implement other two-phase methods." } ] } ], "title": [], "level": 0, "target": null }, "Other Parameters": { "__type": "Section", "__tag": 4015, "children": [], "title": [], "level": 0, "target": null } }, "_ordered_sections": [ "Summary", "Extended Summary", "Parameters", "Attributes", "Methods", "Returns", "Yields", "Receives", "Other Parameters", "Raises", "Warns", "Warnings", "Notes" ], "item_file": "/scipy/optimize/_basinhopping.py", "item_line": 350, "item_type": "function", "aliases": [ "scipy.optimize.basinhopping" ], "example_section_data": { "__type": "Section", "__tag": 4015, "children": [ { "__type": "Text", "__tag": 4046, "value": "The following example is a 1-D minimization problem, with many\nlocal minima superimposed on a parabola.\n\n" }, { "__type": "Code", "__tag": 4050, "value": "import numpy as np\nfrom scipy.optimize import basinhopping\nfunc = lambda x: np.cos(14.5 * x - 0.3) + (x + 0.2) * x\nx0 = [1.]\n", "execution_status": "success" }, { "__type": "Text", "__tag": 4046, "value": "\nBasinhopping, internally, uses a local minimization algorithm. We will use\nthe parameter `minimizer_kwargs` to tell basinhopping which algorithm to\nuse and how to set up that minimizer. This parameter will be passed to\n`scipy.optimize.minimize`.\n\n" }, { "__type": "Code", "__tag": 4050, "value": "minimizer_kwargs = {\"method\": \"BFGS\"}\nret = basinhopping(func, x0, minimizer_kwargs=minimizer_kwargs,\n niter=200)\n", "execution_status": "success" }, { "__type": "Code", "__tag": 4050, "value": "ret.x, ret.fun\n", "execution_status": "failure" }, { "__type": "Text", "__tag": 4046, "value": "\nNext consider a 2-D minimization problem. Also, this time, we\nwill use gradient information to significantly speed up the search.\n\n" }, { "__type": "Code", "__tag": 4050, "value": "def func2d(x):\n f = np.cos(14.5 * x[0] - 0.3) + (x[1] + 0.2) * x[1] + (x[0] +\n 0.2) * x[0]\n df = np.zeros(2)\n df[0] = -14.5 * np.sin(14.5 * x[0] - 0.3) + 2. * x[0] + 0.2\n df[1] = 2. * x[1] + 0.2\n return f, df\n", "execution_status": "success" }, { "__type": "Text", "__tag": 4046, "value": "\nWe'll also use a different local minimization algorithm. Also, we must tell\nthe minimizer that our function returns both energy and gradient (Jacobian).\n\n" }, { "__type": "Code", "__tag": 4050, "value": "minimizer_kwargs = {\"method\":\"L-BFGS-B\", \"jac\":True}\nx0 = [1.0, 1.0]\nret = basinhopping(func2d, x0, minimizer_kwargs=minimizer_kwargs,\n niter=200)\nprint(\"global minimum: x = [%.4f, %.4f], f(x) = %.4f\" % (ret.x[0],\n ret.x[1],\n ret.fun))\n", "execution_status": "success" }, { "__type": "Text", "__tag": 4046, "value": "\nHere is an example using a custom step-taking routine. Imagine you want\nthe first coordinate to take larger steps than the rest of the coordinates.\nThis can be implemented like so:\n\n" }, { "__type": "Code", "__tag": 4050, "value": "class MyTakeStep:\n def __init__(self, stepsize=0.5):\n self.stepsize = stepsize\n self.rng = np.random.default_rng()\n def __call__(self, x):\n s = self.stepsize\n x[0] += self.rng.uniform(-2.*s, 2.*s)\n x[1:] += self.rng.uniform(-s, s, x[1:].shape)\n return x\n", "execution_status": "success" }, { "__type": "Text", "__tag": 4046, "value": "\nSince ``MyTakeStep.stepsize`` exists basinhopping will adjust the magnitude\nof `stepsize` to optimize the search. We'll use the same 2-D function as\nbefore\n\n" }, { "__type": "Code", "__tag": 4050, "value": "mytakestep = MyTakeStep()\nret = basinhopping(func2d, x0, minimizer_kwargs=minimizer_kwargs,\n niter=200, take_step=mytakestep)\nprint(\"global minimum: x = [%.4f, %.4f], f(x) = %.4f\" % (ret.x[0],\n ret.x[1],\n ret.fun))\n", "execution_status": "success" }, { "__type": "Text", "__tag": 4046, "value": "\nNow, let's do an example using a custom callback function which prints the\nvalue of every minimum found\n\n" }, { "__type": "Code", "__tag": 4050, "value": "def print_fun(x, f, accepted):\n print(\"at minimum %.4f accepted %d\" % (f, int(accepted)))\n", "execution_status": "success" }, { "__type": "Text", "__tag": 4046, "value": "\nWe'll run it for only 10 basinhopping steps this time.\n\n" }, { "__type": "Code", "__tag": 4050, "value": "rng = np.random.default_rng()\n", "execution_status": "success" }, { "__type": "Code", "__tag": 4050, "value": "ret = basinhopping(func2d, x0, minimizer_kwargs=minimizer_kwargs,\n niter=10, callback=print_fun, rng=rng)\n", "execution_status": "failure" }, { "__type": "Text", "__tag": 4046, "value": "\nThe minimum at -1.0109 is actually the global minimum, found already on the\n8th iteration." } ], "title": [], "level": 0, "target": null }, "see_also": [ { "__type": "SeeAlsoItem", "__tag": 4028, "name": { "__type": "CrossRef", "__tag": 4002, "value": "minimize", "reference": { "__type": "RefInfo", "__tag": 4000, "module": "current-module", "version": "current-version", "kind": "to-resolve", "path": "minimize" }, "kind": "module" }, "descriptions": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "The local minimization function called once for each basinhopping step. " }, { "__type": "InlineRole", "__tag": 4003, "value": "minimizer_kwargs", "domain": null, "role": null, "inventory": null }, { "__type": "Text", "__tag": 4046, "value": " is passed to this routine." } ] } ], "type": "func" } ], "signature": { "__type": "SignatureNode", "__tag": 4029, "kind": "function", "parameters": [ { "__type": "SigParam", "__tag": 4030, "name": "func", "annotation": { "__type": "Empty", "__tag": 4031 }, "kind": "POSITIONAL_OR_KEYWORD", "default": { "__type": "Empty", "__tag": 4031 } }, { "__type": "SigParam", "__tag": 4030, "name": "x0", "annotation": { "__type": "Empty", "__tag": 4031 }, "kind": "POSITIONAL_OR_KEYWORD", "default": { "__type": "Empty", "__tag": 4031 } }, { "__type": "SigParam", "__tag": 4030, "name": "niter", "annotation": { "__type": "Empty", "__tag": 4031 }, "kind": "POSITIONAL_OR_KEYWORD", "default": "100" }, { "__type": "SigParam", "__tag": 4030, "name": "T", "annotation": { "__type": "Empty", "__tag": 4031 }, "kind": "POSITIONAL_OR_KEYWORD", "default": "1.0" }, { "__type": "SigParam", "__tag": 4030, "name": "stepsize", "annotation": { "__type": "Empty", "__tag": 4031 }, "kind": "POSITIONAL_OR_KEYWORD", "default": "0.5" }, { "__type": "SigParam", "__tag": 4030, "name": "minimizer_kwargs", "annotation": { "__type": "Empty", "__tag": 4031 }, "kind": "POSITIONAL_OR_KEYWORD", "default": "None" }, { "__type": "SigParam", "__tag": 4030, "name": "take_step", "annotation": { "__type": "Empty", "__tag": 4031 }, "kind": "POSITIONAL_OR_KEYWORD", "default": "None" }, { "__type": "SigParam", "__tag": 4030, "name": "accept_test", "annotation": { "__type": "Empty", "__tag": 4031 }, "kind": "POSITIONAL_OR_KEYWORD", "default": "None" }, { "__type": "SigParam", "__tag": 4030, "name": "callback", "annotation": { "__type": "Empty", "__tag": 4031 }, "kind": "POSITIONAL_OR_KEYWORD", "default": "None" }, { "__type": "SigParam", "__tag": 4030, "name": "interval", "annotation": { "__type": "Empty", "__tag": 4031 }, "kind": "POSITIONAL_OR_KEYWORD", "default": "50" }, { "__type": "SigParam", "__tag": 4030, "name": "disp", "annotation": { "__type": "Empty", "__tag": 4031 }, "kind": "POSITIONAL_OR_KEYWORD", "default": "False" }, { "__type": "SigParam", "__tag": 4030, "name": "niter_success", "annotation": { "__type": "Empty", "__tag": 4031 }, "kind": "POSITIONAL_OR_KEYWORD", "default": "None" }, { "__type": "SigParam", "__tag": 4030, "name": "rng", "annotation": { "__type": "Empty", "__tag": 4031 }, "kind": "POSITIONAL_OR_KEYWORD", "default": "None" }, { "__type": "SigParam", "__tag": 4030, "name": "target_accept_rate", "annotation": { "__type": "Empty", "__tag": 4031 }, "kind": "KEYWORD_ONLY", "default": "0.5" }, { "__type": "SigParam", "__tag": 4030, "name": "stepwise_factor", "annotation": { "__type": "Empty", "__tag": 4031 }, "kind": "KEYWORD_ONLY", "default": "0.9" }, { "__type": "SigParam", "__tag": 4030, "name": "seed", "annotation": { "__type": "Empty", "__tag": 4031 }, "kind": "KEYWORD_ONLY", "default": "None" } ], "return_annotation": { "__type": "Empty", "__tag": 4031 }, "target_name": "basinhopping" }, "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`" ], "qa": "scipy.optimize._basinhopping:basinhopping", "arbitrary": [], "local_refs": [ "T", "accept_test", "callback", "disp", "func", "interval", "minimizer_kwargs", "niter", "niter_success", "res", "rng", "stepsize", "stepwise_factor", "take_step", "target_accept_rate", "x0" ] }