Nonlinear constraint optimization in SciPy - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to import the function for nonlinear optimization from scipy.

SciPy

from scipy.optimize import [1]

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

Aminimize

Blinprog

Ccurve_fit

Droot

Attempts:

3 left

💡 Hint

Common Mistakes

Using linprog which is for linear programming.

Using curve_fit which is for curve fitting.

Using root which is for finding roots of equations.

The minimize function from scipy.optimize is used for nonlinear optimization problems.

2fill in blank

medium

Complete the code to define the nonlinear constraint function that must be greater than or equal to zero.

SciPy

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

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

A1

B0

C-1

D2

Attempts:

3 left

💡 Hint

Common Mistakes

Using 0 which would change the constraint meaning.

Using negative values which are not correct for this constraint.

Using 2 which changes the radius.

The constraint x[0]**2 + x[1]**2 - 1 >= 0 means the point lies outside or on the unit circle.

3fill in blank

hard

Fix the error in the constraint dictionary by completing the 'type' field correctly.

SciPy

nonlinear_constraint = {'type': '[1]', 'fun': constraint}

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

Amax

Beq

Cmin

Dineq

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'eq' which means equality constraint.

Using 'min' or 'max' which are not valid types.

The 'ineq' type means the constraint function should be >= 0, which is correct for nonlinear inequality constraints.

4fill in blank

hard

Fill both blanks to complete the call to minimize with the objective function and constraints.

SciPy

result = minimize([1], x0, constraints=[2])

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

Aobjective

Bx0

C[nonlinear_constraint]

Dconstraints

Attempts:

3 left

💡 Hint

Common Mistakes

Passing x0 as the first argument instead of the objective function.

Passing constraints directly without a list.

The minimize function requires the objective function as the first argument and a list of constraints as the constraints parameter.

5fill in blank

hard

Fill all three blanks to create a dictionary comprehension that maps indices to their optimized values if the value is greater than zero.

SciPy

positive_vars = { [1]: result.x[[2]] for [3] in range(len(result.x)) if result.x[[3]] > 0 }

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

A{var

Bi

Cvar

D}

Attempts:

3 left

💡 Hint

Common Mistakes

Using a string like '{var' for the key.

Using incorrect loop variable names.

Not filtering values greater than zero.

This dictionary comprehension creates a dictionary with keys as indices and values as their positive optimized values.

Practice

1. What is the main purpose of using nonlinear constraint optimization in scipy.optimize.minimize?

easy

A. To generate random numbers

B. To sort data in ascending order

C. To calculate the mean of a dataset

D. To find the best solution while respecting complex rules or limits

Solution

1. Step 1: Understand the goal of optimization

   Optimization aims to find the best value of a function, often minimum or maximum.

2. Step 2: Recognize the role of constraints

   Nonlinear constraint optimization includes rules that the solution must follow, making it more complex.

3. Final Answer:

   To find the best solution while respecting complex rules or limits -> Option D

4. Quick Check:

   Optimization with constraints = best solution with rules [OK]

Hint: Optimization with constraints means best solution obeying rules [OK]

Common Mistakes:

• Confusing optimization with sorting
• Thinking it calculates statistics like mean
• Assuming it generates random data

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

easy

A. constraints = {'ineq', lambda x: x[0] - 1}

B. constraints = ['type' = 'ineq', 'fun' = lambda x: x[0] - 1]

C. constraints = {'type': 'ineq', 'fun': lambda x: x[0] - 1}

D. constraints = ('ineq', lambda x: x[0] - 1)

Solution

1. Step 1: Recall the constraints format

   Constraints must be a dictionary with keys 'type' and 'fun'.

2. Step 2: Check each option's syntax

   constraints = {'type': 'ineq', 'fun': lambda x: x[0] - 1} uses a dictionary with correct keys and lambda function syntax.

3. Final Answer:

   constraints = {'type': 'ineq', 'fun': lambda x: x[0] - 1} -> Option C

4. Quick Check:

   Constraints as dict with 'type' and 'fun' keys = constraints = {'type': 'ineq', 'fun': lambda x: x[0] - 1} [OK]

Hint: Constraints need dict with 'type' and 'fun' keys [OK]

Common Mistakes:

• Using list or tuple instead of dict
• Wrong assignment syntax inside list
• Missing keys or using set instead of dict

3. What is the output of this code snippet?

from scipy.optimize import minimize

obj_fun = lambda x: (x[0]-2)**2 + (x[1]-3)**2
constraint = {'type': 'ineq', 'fun': lambda x: x[0] + x[1] - 4}
result = minimize(obj_fun, [0, 0], constraints=constraint, method='SLSQP')
print(round(result.fun, 2))

medium

A. 0.00

B. 1.00

C. 2.00

D. 4.00

Solution

1. Step 1: Understand the objective function

   The function measures distance squared from point (2,3).

2. Step 2: Apply the constraint and minimize

   The constraint requires x[0] + x[1] >= 4. The closest point to (2,3) on this line is (1,3), giving value (1-2)^2+(3-3)^2=1.

3. Final Answer:

   1.00 -> Option B

4. Quick Check:

   Minimum distance squared with constraint = 1.00 [OK]

Hint: Check closest point on constraint line to target point [OK]

Common Mistakes:

• Ignoring the constraint
• Rounding incorrectly
• Confusing objective function value with variables

4. Identify the error in this code for nonlinear constraint optimization:

from scipy.optimize import minimize

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

constraint = {'type': 'eq', 'fun': lambda x: x[0] + x[1] - 1}

result = minimize(obj, [0, 0], constraints=constraint, method='SLSQP')
print(result.x)

medium

A. Initial guess violates the equality constraint

B. Constraint type should be 'ineq' instead of 'eq'

C. Objective function must be linear

D. Method 'SLSQP' does not support constraints

Solution

1. Step 1: Check initial guess against constraint

   Initial guess [0,0] does not satisfy x[0] + x[1] = 1.

2. Step 2: Understand impact on solver

   Starting point violating equality constraints can cause solver to fail or converge slowly.

3. Final Answer:

   Initial guess violates the equality constraint -> Option A

4. Quick Check:

   Initial guess must satisfy equality constraints [OK]

Hint: Start with guess satisfying equality constraints [OK]

Common Mistakes:

• Using wrong constraint type
• Assuming objective must be linear
• Thinking SLSQP can't handle constraints

5. You want to minimize f(x) = (x[0]-1)^2 + (x[1]-2)^2 subject to nonlinear constraints x[0]^2 + x[1]^2 <= 2 and x[0] - x[1] >= 0. Which is the correct way to define these constraints for scipy.optimize.minimize with method 'SLSQP'?

hard

A. [{'type': 'ineq', 'fun': lambda x: 2 - (x[0]**2 + x[1]**2)}, {'type': 'ineq', 'fun': lambda x: x[0] - x[1]}]

B. [{'type': 'eq', 'fun': lambda x: 2 - (x[0]**2 + x[1]**2)}, {'type': 'eq', 'fun': lambda x: x[0] - x[1]}]

C. [{'type': 'ineq', 'fun': lambda x: (x[0]**2 + x[1]**2) - 2}, {'type': 'ineq', 'fun': lambda x: x[1] - x[0]}]

D. [{'type': 'ineq', 'fun': lambda x: (x[0]**2 + x[1]**2) - 2}, {'type': 'ineq', 'fun': lambda x: x[0] - x[1]}]

Solution

1. Step 1: Translate constraints to 'ineq' form

   For 'ineq', function must be >= 0. So x0^2+x1^2 <= 2 becomes 2 - (x0^2+x1^2) >= 0.

2. Step 2: Check second constraint

   x0 - x1 >= 0 is already in correct form.

3. Final Answer:

   [{'type': 'ineq', 'fun': lambda x: 2 - (x[0]**2 + x[1]**2)}, {'type': 'ineq', 'fun': lambda x: x[0] - x[1]}] -> Option A

4. Quick Check:

   Constraints must be 'ineq' with function >= 0 [OK]

Hint: Rewrite constraints so function >= 0 for 'ineq' type [OK]

Common Mistakes:

• Using 'eq' instead of 'ineq' for inequalities
• Reversing inequality signs
• Not rewriting constraints to >= 0 form