Basin-hopping for global minima in SciPy - Mini Project: Build & Apply

Basin-hopping for Global Minima

📖 Scenario: You are working as a data scientist helping a company find the lowest point of a complex landscape. This is like finding the deepest valley in a mountain range. The company wants to use a smart method called basin-hopping to find the lowest point (global minimum) of a tricky function that has many hills and valleys.

🎯 Goal: Build a Python program that uses scipy.optimize.basinhopping to find the global minimum of a given function. You will first define the function, then set up the basin-hopping configuration, run the algorithm, and finally print the best solution found.

📋 What You'll Learn

Define a function func that takes a list or array x and returns a value.

Create a starting point variable x0 as a list with two numbers.

Set up a basin-hopping configuration variable niter to control the number of iterations.

Use scipy.optimize.basinhopping with func, x0, and niter to find the global minimum.

Print the best solution's coordinates and function value.

💡 Why This Matters

🌍 Real World

Basin-hopping is used in chemistry, physics, and engineering to find the lowest energy states or best solutions in complex problems with many local minima.

💼 Career

Understanding global optimization techniques like basin-hopping is valuable for data scientists working on optimization problems, machine learning model tuning, and scientific computing.

1

Define the function to minimize

Define a function called func that takes a single argument x. Inside, return the value of (x[0] - 1)**2 + (x[1] - 2)**2 + 1. This function represents a simple landscape with a minimum.

SciPy

# Define the function func(x) here
# Your code here

Hint

Remember, x is a list or array with two elements. Use x[0] and x[1] to access them.

2

Set the starting point and iteration count

Create a variable called x0 and set it to the list [0, 0]. Then create a variable called niter and set it to 100. These will be used as the starting point and number of iterations for basin-hopping.

SciPy

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

# Create x0 and niter variables here
# Your code here

Hint

Use a list for x0 with two numbers, and an integer for niter.

3

Run basin-hopping to find the global minimum

Import basinhopping from scipy.optimize. Then run basinhopping with func, x0, and niter as the number of iterations. Store the result in a variable called result.

SciPy

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

x0 = [0, 0]
niter = 100

# Import basinhopping and run it to get result
# Your code here

Hint

Use from scipy.optimize import basinhopping and call basinhopping(func, x0, niter=niter).

4

Print the best solution found

Print the best solution's coordinates using result.x and the function value at that point using result.fun. Use two separate print statements with the exact text: print("Best coordinates:", result.x) and print("Function value:", result.fun).

SciPy

from scipy.optimize import basinhopping

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

x0 = [0, 0]
niter = 100

result = basinhopping(func, x0, niter=niter)

# Print the best coordinates and function value
# Your code here

Hint

Use print("Best coordinates:", result.x) and print("Function value:", result.fun).

Practice

1. What is the main purpose of the basin-hopping algorithm in optimization?

easy

A. To calculate the derivative of a function

B. To perform a simple linear regression

C. To sort a list of numbers efficiently

D. To find the global minimum of a function with many local minima

Solution

1. Step 1: Understand the goal of basin-hopping

   Basin-hopping is designed to find the lowest point (global minimum) in complex functions that have many dips (local minima).

2. Step 2: Compare with other options

   Options A, B, and C describe unrelated tasks: differentiation, regression, and sorting, which are not the purpose of basin-hopping.

3. Final Answer:

   To find the global minimum of a function with many local minima -> Option D

4. Quick Check:

   Basin-hopping = global minimum search [OK]

Hint: Basin-hopping = global minimum finder in tricky functions [OK]

Common Mistakes:

• Confusing basin-hopping with simple optimization methods
• Thinking it sorts or differentiates functions
• Assuming it only finds local minima

2. Which of the following is the correct way to import the basin-hopping function from scipy?

easy

A. from scipy import basinhopping

B. import scipy.basinhopping

C. from scipy.optimize import basinhopping

D. import basinhopping from scipy.optimize

Solution

1. Step 1: Recall correct import syntax in Python

   To import a specific function from a module, use 'from module import function'.

2. Step 2: Match with scipy.optimize and basinhopping

   The basin-hopping function is inside scipy.optimize, so the correct import is 'from scipy.optimize import basinhopping'.

3. Final Answer:

   from scipy.optimize import basinhopping -> Option C

4. Quick Check:

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

Hint: Use 'from scipy.optimize import basinhopping' to import [OK]

Common Mistakes:

• Using incorrect import order or syntax
• Trying to import basin-hopping directly from scipy
• Using 'import basinhopping from ...' which is invalid

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

import numpy as np
from scipy.optimize import basinhopping

def func(x):
    return (x - 3)**2 + 5

result = basinhopping(func, x0=0, niter=5)
print(round(result.fun, 2))

medium

A. 5.00

B. 0.00

C. 9.00

D. 3.00

Solution

1. Step 1: Understand the function and its minimum

   The function is (x - 3)^2 + 5, which has its minimum value at x=3, and the minimum value is 5.

2. Step 2: Analyze basin-hopping output

   Basin-hopping tries to find the global minimum. Starting at x0=0, after 5 iterations, it should find near x=3, so the function value is near 5.

3. Final Answer:

   5.00 -> Option A

4. Quick Check:

   Minimum value of (x-3)^2+5 = 5 [OK]

Hint: Minimum of (x-3)^2+5 is 5 at x=3 [OK]

Common Mistakes:

• Confusing minimum value with x-coordinate
• Assuming starting point is the minimum
• Ignoring the constant +5 in the function

4. Identify the error in the following code using basin-hopping:

from scipy.optimize import basinhopping

def f(x):
    return x**2

result = basinhopping(f, x0=[1, 2], niter=10)
print(result.x)

medium

A. No error; code runs correctly

B. Function f must return a scalar, but it returns a list

C. x0 should be a numpy array, not a list

D. x0 should be a scalar, not a list

Solution

1. Step 1: Check input types for basin-hopping

   basinhopping accepts x0 as a scalar or array-like. A list like [1, 2] is valid and converted to numpy array internally.

2. Step 2: Verify function output

   Function f(x) = x**2. For vector x = np.array([1,2]), it returns np.array([1,4]), not a scalar. Optimization requires scalar objective function value.

3. Step 3: Test code behavior

   The code raises an error because the objective function returns an array instead of scalar.

4. Final Answer:

   Function f must return a scalar, but it returns a list -> Option B

5. Quick Check:

   Objective func must return scalar [OK]

Hint: basinhopping objective must return scalar for vector x0 [OK]

Common Mistakes:

• Assuming no error; overlooking non-scalar function return
• Thinking x0 list causes the error
• Believing x0 must be scalar or explicit numpy array

5. You want to find the global minimum of a function with many local minima using basin-hopping. Which parameter should you adjust to increase the chance of escaping local minima?

hard

A. Increase the 'stepsize' parameter to allow bigger jumps

B. Decrease the 'niter' parameter to reduce iterations

C. Set 'minimizer_kwargs' to None

D. Use a fixed starting point without randomization

Solution

1. Step 1: Understand basin-hopping parameters

   'stepsize' controls how big the random jumps are between local minimizations. Bigger steps help jump out of local minima.

2. Step 2: Evaluate options

   Decreasing 'niter' reduces attempts, lowering success. Setting 'minimizer_kwargs' to None disables local minimization, which is needed. Fixed start without randomization limits exploration.

3. Final Answer:

   Increase the 'stepsize' parameter to allow bigger jumps -> Option A

4. Quick Check:

   Bigger stepsize = better escape from local minima [OK]

Hint: Bigger stepsize helps jump out of local minima [OK]

Common Mistakes:

• Reducing iterations thinking it speeds up convergence
• Disabling local minimization by setting minimizer_kwargs to None
• Using fixed start point limits search space