0
Jump into concepts and practice - no test required
Recommended
Simulated annealing helps find the best answer when there are many possibilities. It tries different solutions and slowly focuses on the best one.
from scipy.optimize import dual_annealing result = dual_annealing(func, bounds) # func: function to minimize # bounds: list of (min, max) tuples for each variable
The func should take a list or array and return a number to minimize.
bounds define the search space for each variable.
def f(x): return (x[0] - 1)**2 + (x[1] + 2)**2 bounds = [(-5, 5), (-5, 5)] result = dual_annealing(f, bounds) print(result.x, result.fun)
def sphere(x): return sum(xi**2 for xi in x) bounds = [(-10, 10)] * 3 result = dual_annealing(sphere, bounds) print(result.x, result.fun)
This program finds the minimum of a simple 2D function using simulated annealing. It searches between -10 and 10 for both variables.
from scipy.optimize import dual_annealing def objective(x): # Simple function with minimum at (3, -1) return (x[0] - 3)**2 + (x[1] + 1)**2 bounds = [(-10, 10), (-10, 10)] result = dual_annealing(objective, bounds) print(f"Best solution: {result.x}") print(f"Minimum value: {result.fun}")
Simulated annealing can find good solutions even if the problem has many local minima.
Results may slightly vary each run because of randomness.
Set bounds carefully to limit the search space and speed up the process.
Simulated annealing tries many solutions and slowly focuses on the best one.
Use dual_annealing from scipy.optimize to minimize functions with bounds.
It works well for complex problems with many possible answers.
dual_annealing in scipy.optimize?dual_annealing is an optimization method used to find the minimum of a function, especially when the function is complex and has many local minima.dual_annealing.dual_annealing from scipy.optimize?from module import function.from scipy.optimize import dual_annealing. Other options have incorrect syntax.from scipy.optimize import dual_annealing
def f(x):
return (x[0] - 3)**2 + (x[1] + 1)**2
bounds = [(-5, 5), (-5, 5)]
result = dual_annealing(f, bounds)
print(round(result.fun, 2))f(x) calculates the sum of squares of (x[0]-3) and (x[1]+1). The minimum is at x[0]=3 and x[1]=-1, where the function value is 0.x[0]=3 and x[1]=-1. So the optimizer should find the minimum function value close to 0. The print statement rounds the result to 2 decimals.dual_annealing:
from scipy.optimize import dual_annealing
def f(x):
return x**2
bounds = [(-2, 2)]
result = dual_annealing(f, bounds)
print(result.x)dual_annealing passes an array (even if one variable), but f(x) expects a scalar x. This mismatch causes an error.dual_annealing requires bounds. No numpy import needed here.f(x) = (x[0]-2)^2 + (x[1]-3)^2 but only allow x[0] between 0 and 1, and x[1] between 2 and 4. Which code correctly uses dual_annealing to find the minimum within these bounds?x[0]=2, x[1]=3. But bounds restrict x[0] to [0,1] and x[1] to [2,4]. So the optimizer must search within these bounds.bounds = [(0, 1), (2, 4)]
result = dual_annealing(f, bounds) correctly sets bounds as [(0,1), (2,4)] and passes them to dual_annealing. The code bounds = [(2, 3), (3, 4)]
result = dual_annealing(f, bounds) has wrong bounds. The code bounds = [(0, 2), (2, 3)]
result = dual_annealing(f, bounds) has wrong bounds. The code bounds = [(0, 1), (2, 4)]
result = dual_annealing(f) misses bounds argument.