Simulated annealing (dual_annealing) in SciPy - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of dual_annealing on a simple quadratic function

What is the output of the following code snippet using scipy.optimize.dual_annealing on a quadratic function?

SciPy

from scipy.optimize import dual_annealing

def func(x):
    return (x[0] - 3)**2 + (x[1] + 1)**2

bounds = [(-5, 5), (-5, 5)]
result = dual_annealing(func, bounds)
print((round(result.x[0], 1), round(result.x[1], 1)))

A (-3.0, 1.0)

B (0.0, 0.0)

C (3.0, -1.0)

D (-5.0, -5.0)

💡 Hint

The function has its minimum where both squared terms are zero.

The function is minimized when x[0] = 3 and x[1] = -1, so the optimizer should find values close to these.

❓ data_output

intermediate

Number of iterations in dual_annealing result

After running dual_annealing on a function, what is the value of result.nit representing the number of iterations?

SciPy

from scipy.optimize import dual_annealing
import numpy as np

def func(x):
    return np.sin(x[0]) + np.cos(x[1])

bounds = [(0, 10), (0, 10)]
result = dual_annealing(func, bounds)
print(result.nit)

A A float representing the function minimum value

B An integer greater than zero representing iterations performed

C A tuple with the best solution coordinates

D A boolean indicating success or failure

💡 Hint

Check the documentation for result.nit attribute.

result.nit is the number of iterations the algorithm ran before stopping, always an integer >= 0.

🔧 Debug

advanced

Identify the error in dual_annealing usage

What error will this code raise when running dual_annealing with incorrect bounds?

SciPy

from scipy.optimize import dual_annealing

def func(x):
    return x[0]**2

bounds = [(0, 5), (1, 0)]  # Note the second bound is reversed
result = dual_annealing(func, bounds)

A No error, runs successfully

B TypeError: func() missing 1 required positional argument

C RuntimeError: Maximum number of iterations exceeded

D ValueError: bounds must be in increasing order

💡 Hint

Bounds must be specified with lower bound less than upper bound.

The second bound (1, 0) is invalid because the lower bound is greater than the upper bound, causing a ValueError.

🧠 Conceptual

advanced

Why use dual_annealing over other optimizers?

Which reason best explains why dual_annealing is chosen for optimization problems?

A It combines stochastic and local search to escape local minima

B It requires no bounds and works on infinite domains

C It only works for linear functions but is very fast

D It is guaranteed to find the global minimum for any function

💡 Hint

Think about how simulated annealing helps avoid local traps.

dual_annealing uses a combination of stochastic sampling and local search to escape local minima and find better solutions.

🚀 Application

expert

Interpreting dual_annealing output for a noisy function

Given this noisy function and dual_annealing output, what is the best interpretation of the result's fun value?

SciPy

from scipy.optimize import dual_annealing
import numpy as np

def noisy_func(x):
    noise = np.random.normal(0, 0.1)
    return (x[0] - 2)**2 + noise

bounds = [(0, 4)]
result = dual_annealing(noisy_func, bounds)
print(round(result.fun, 2))

A An approximate minimum value affected by noise

B The maximum value found during optimization

C The exact minimum value of the function without noise

D A constant zero because noise averages out

💡 Hint

Consider how noise affects function evaluations during optimization.

Because the function includes random noise, the fun value is an approximation and may vary slightly each run.

Practice

1. What is the main purpose of using dual_annealing in scipy.optimize?

easy

A. To find the minimum value of a function within given bounds

B. To sort a list of numbers in ascending order

C. To calculate the mean of a dataset

D. To generate random numbers following a normal distribution

Solution

1. Step 1: Understand the purpose of dual_annealing

   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.

2. Step 2: Identify the correct use case

   Among the options, only finding the minimum value of a function within bounds matches the purpose of dual_annealing.

3. Final Answer:

   To find the minimum value of a function within given bounds -> Option A

4. Quick Check:

   Optimization = Find minimum [OK]

Hint: dual_annealing is for minimizing functions with bounds [OK]

Common Mistakes:

• Confusing optimization with sorting or statistics
• Thinking dual_annealing generates random numbers
• Assuming it calculates averages

2. Which of the following is the correct way to import dual_annealing from scipy.optimize?

easy

A. from scipy.optimize import dual_annealing

B. import dual_annealing from scipy.optimize

C. from scipy import dual_annealing.optimize

D. import scipy.optimize.dual_annealing

Solution

1. Step 1: Recall Python import syntax

   The correct syntax to import a function from a module is from module import function.

2. Step 2: Match syntax to options

   from scipy.optimize import dual_annealing matches the correct syntax: from scipy.optimize import dual_annealing. Other options have incorrect syntax.

3. Final Answer:

   from scipy.optimize import dual_annealing -> Option A

4. Quick Check:

   Correct import syntax = from scipy.optimize import dual_annealing [OK]

Hint: Use 'from module import function' to import dual_annealing [OK]

Common Mistakes:

• Using 'import function from module' which is invalid
• Trying to import submodules incorrectly
• Using dot notation in import statements wrongly

3. What will be the output of the following code snippet?

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))

medium

A. 10.00

B. 0.00

C. 4.00

D. Error

Solution

1. Step 1: Understand the function and bounds

   The function 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.

2. Step 2: dual_annealing finds the minimum within bounds

   The bounds allow 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.

3. Final Answer:

   0.00 -> Option B

4. Quick Check:

   Minimum value = 0.00 [OK]

Hint: Minimum of squared distance function is zero at target point [OK]

Common Mistakes:

• Assuming the minimum is outside bounds
• Confusing function value with input values
• Expecting an error due to function shape

4. Identify the error in the following code using 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)

medium

A. dual_annealing requires no bounds argument

B. Bounds should be a tuple, not a list

C. Function f expects a scalar but dual_annealing passes an array

D. Missing import for numpy

Solution

1. Step 1: Check function input type

   dual_annealing passes an array (even if one variable), but f(x) expects a scalar x. This mismatch causes an error.

2. Step 2: Verify bounds and imports

   Bounds as a list of tuples is correct. dual_annealing requires bounds. No numpy import needed here.

3. Final Answer:

   Function f expects a scalar but dual_annealing passes an array -> Option C

4. Quick Check:

   Function input type mismatch = Function f expects a scalar but dual_annealing passes an array [OK]

Hint: dual_annealing passes array input; function must accept array [OK]

Common Mistakes:

• Assuming bounds format is wrong
• Thinking numpy import is mandatory here
• Ignoring input type mismatch

5. You want to minimize the function 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?

hard

A. bounds = [(0, 1), (2, 4)]
result = dual_annealing(f)

B. bounds = [(2, 3), (3, 4)]
result = dual_annealing(f, bounds)

C. bounds = [(0, 2), (2, 3)]
result = dual_annealing(f, bounds)

D. bounds = [(0, 1), (2, 4)]
result = dual_annealing(f, bounds)

Solution

1. Step 1: Understand the function and bounds

   The function minimum is at 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.

2. Step 2: Check code options for correct bounds and usage

   The code 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.

3. Final Answer:

   bounds = [(0, 1), (2, 4)] result = dual_annealing(f, bounds) -> Option D

4. Quick Check:

   Correct bounds and function call = bounds = [(0, 1), (2, 4)] result = dual_annealing(f, bounds) [OK]

Hint: Bounds must match variable limits and be passed to dual_annealing [OK]

Common Mistakes:

• Using wrong bounds that exclude minimum
• Not passing bounds argument to dual_annealing
• Confusing variable order in bounds