Method selection (Nelder-Mead, BFGS, Powell) in SciPy - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to import the minimize function from scipy.optimize.

SciPy

from scipy.optimize import [1]

Drag options to blanks, or click blank then click option'

Aminimize

Boptimize

Cmin

Dopt

Attempts:

3 left

💡 Hint

Common Mistakes

Importing 'optimize' instead of 'minimize'.

Using 'min' which is a built-in function, not from scipy.

The minimize function is imported from scipy.optimize to perform optimization.

2fill in blank

medium

Complete the code to define the function to minimize: f(x) = (x-3)^2.

SciPy

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

Drag options to blanks, or click blank then click option'

A+

B/

C*

D-

Attempts:

3 left

💡 Hint

Common Mistakes

Using '+' instead of '-' which changes the function.

Using '*' or '/' which are incorrect here.

The function is (x - 3) squared, so the operator between x and 3 is subtraction '-'.

3fill in blank

hard

Fix the error in the code to minimize the function using the Nelder-Mead method.

SciPy

result = minimize(func, x0=0, method=[1])

Drag options to blanks, or click blank then click option'

A'BFGS'

B'Gradient'

C'Nelder-Mead'

D'Powell'

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'BFGS' or 'Powell' instead of 'Nelder-Mead'.

Using 'Gradient' which is not a valid method name.

The method name for Nelder-Mead must be exactly 'Nelder-Mead' as a string.

4fill in blank

hard

Fill both blanks to minimize the function using the BFGS method starting at x=2.

SciPy

result = minimize(func, x0=[1], method=[2])

Drag options to blanks, or click blank then click option'

A2

B'BFGS'

C'Nelder-Mead'

D0

Attempts:

3 left

💡 Hint

Common Mistakes

Using x0=0 instead of 2.

Using method 'Nelder-Mead' instead of 'BFGS'.

We start at x=2 and use the method 'BFGS' for minimization.

5fill in blank

hard

Fill all three blanks to minimize the function using Powell method starting at x=1 and print the optimized value.

SciPy

result = minimize(func, x0=[1], method=[2])
print(result.[3])

Drag options to blanks, or click blank then click option'

A1

B'Powell'

Cx

Exopt

Fx0

Gxval

Attempts:

3 left

💡 Hint

Common Mistakes

Using wrong method names.

Trying to print result.xopt or other invalid attributes.

The starting point is 1, method is 'Powell', and the optimized value is accessed by result.x.

Practice

1. Which optimization method in scipy.optimize.minimize should you choose if you do NOT have information about the slope (gradient) of the function?

easy

A. BFGS

B. Nelder-Mead

C. Powell

D. CG

Solution

1. Step 1: Understand slope information requirement

   BFGS requires slope (gradient) information, while Nelder-Mead and Powell do not.

2. Step 2: Identify method without slope info

   Nelder-Mead is designed for optimization without slope info, making it suitable here.

3. Final Answer:

   Nelder-Mead -> Option B

4. Quick Check:

   No slope info = Nelder-Mead [OK]

Hint: No slope info? Pick Nelder-Mead [OK]

Common Mistakes:

• Choosing BFGS without slope info
• Confusing Powell with BFGS
• Assuming CG works without slope info

2. Which of the following is the correct way to specify the Powell method in scipy.optimize.minimize?

easy

A. minimize(fun, x0, method='Powell')

B. minimize(fun, x0, method='powl')

C. minimize(fun, x0, method='POWELL')

D. minimize(fun, x0, method='powell')

Solution

1. Step 1: Check method name case sensitivity

   Method names in scipy.optimize.minimize are case-sensitive and lowercase.

2. Step 2: Match exact method string

   The correct string is 'powell' all lowercase, so minimize(fun, x0, method='powell') is correct.

3. Final Answer:

   minimize(fun, x0, method='powell') -> Option D

4. Quick Check:

   Method name is lowercase 'powell' [OK]

Hint: Method names are lowercase strings [OK]

Common Mistakes:

• Using uppercase method names
• Typo in method string
• Using partial method names

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

from scipy.optimize import minimize

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

result = minimize(f, [0, 0], method='BFGS')
print(round(result.x[0], 1), round(result.x[1], 1))

medium

A. (3.0, -1.0)

B. (0.0, 0.0)

C. (3.0, 1.0)

D. Error due to missing gradient

Solution

1. Step 1: Understand the function and starting point

   The function has minimum at x=3, y=-1. Starting point is [0,0].

2. Step 2: BFGS uses gradient approximation to find minimum

   BFGS will find the minimum near (3, -1) accurately.

3. Final Answer:

   (3.0, -1.0) -> Option A

4. Quick Check:

   Minimum at (3,-1) found by BFGS [OK]

Hint: BFGS finds minimum near true minimum fast [OK]

Common Mistakes:

• Assuming output is starting point
• Thinking gradient is required explicitly
• Confusing signs in minimum location

4. Identify the error in this code snippet using Nelder-Mead method:

from scipy.optimize import minimize

def f(x):
    return x**2 + 4*x + 4

result = minimize(f, 2, method='Nelder-Mead')
print(result.x)

medium

A. Initial guess must be a list or array, not a scalar

B. Function must return a vector, not scalar

C. Method 'Nelder-Mead' is not supported

D. Missing gradient function

Solution

1. Step 1: Check input type for initial guess

   Minimize expects initial guess as array-like, but 2 is scalar.

2. Step 2: Confirm correct input format

   Passing [2] or np.array([2]) fixes the error.

3. Final Answer:

   Initial guess must be a list or array, not a scalar -> Option A

4. Quick Check:

   Initial guess scalar causes error [OK]

Hint: Initial guess must be array-like, not single number [OK]

Common Mistakes:

• Passing scalar initial guess
• Expecting gradient for Nelder-Mead
• Wrong method name casing

5. You want to minimize a function where you have no gradient info, but the function is noisy and non-smooth. Which method is best to try first in scipy.optimize.minimize?

hard

A. BFGS

B. Nelder-Mead

C. Powell

D. Newton-CG

Solution

1. Step 1: Analyze method suitability for noisy, non-smooth functions

   BFGS and Newton-CG require gradient info and smoothness, so not ideal.

2. Step 2: Compare Nelder-Mead and Powell for robustness

   Powell is more robust for noisy, non-smooth functions without gradients.

3. Final Answer:

   Powell -> Option C

4. Quick Check:

   No gradient + noisy function = Powell [OK]

Hint: No gradient + noisy? Use Powell method [OK]

Common Mistakes:

• Choosing BFGS without gradient
• Assuming Nelder-Mead is always best
• Ignoring function noise impact