Nonlinear constraint optimization in SciPy - Mini Project: Build & Apply

Nonlinear Constraint Optimization with SciPy

📖 Scenario: Imagine you are helping a small business owner who wants to maximize their profit by deciding how many units of two products to produce. However, there are limits on resources and production rules that must be followed.

🎯 Goal: You will build a program that finds the best number of units for each product to maximize profit while respecting the business constraints using nonlinear constraint optimization.

📋 What You'll Learn

Create a function representing the profit to maximize

Define nonlinear constraints for the problem

Use SciPy's minimize function with method 'SLSQP' to solve the problem

Print the optimal production quantities and maximum profit

💡 Why This Matters

🌍 Real World

Businesses often need to maximize profits or minimize costs while respecting limits on resources, labor, or materials. Nonlinear constraints model real-world rules that are not simple linear limits.

💼 Career

Understanding nonlinear constraint optimization is valuable for roles in operations research, data science, and analytics where decision-making under constraints is common.

1

Define the profit function

Create a function called profit that takes a list x with two elements representing the units of product A and product B. The profit is calculated as 40 * x[0] + 30 * x[1]. Return the negative of this value because SciPy minimizes functions.

SciPy

# Define the profit function that takes x and returns negative profit
# Your code here

Hint

Remember, SciPy's minimize finds minimum values, so return negative profit to maximize.

2

Set up nonlinear constraints

Create a list called constraints with two nonlinear constraints as dictionaries. The first constraint function constraint1 ensures 2 * x[0] + x[1] <= 100. The second constraint function constraint2 ensures x[0] + 2 * x[1] <= 80. Use type: 'ineq' for both constraints, meaning the function should be >= 0.

SciPy

def profit(x):
    return -(40 * x[0] + 30 * x[1])

# Define constraint1 function
# Your code here

Hint

Constraints must be functions returning values >= 0 for valid solutions.

3

Solve the optimization problem

Use SciPy's minimize function to find the optimal units of products A and B. Use initial guess x0 = [0, 0], method 'SLSQP', and the constraints list. Store the result in a variable called result.

SciPy

def profit(x):
    return -(40 * x[0] + 30 * x[1])

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

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

constraints = [
    {'type': 'ineq', 'fun': constraint1},
    {'type': 'ineq', 'fun': constraint2}
]

# Import minimize from scipy.optimize
# Use minimize with profit, x0=[0, 0], method='SLSQP', and constraints
# Store result in variable result
# Your code here

Hint

Remember to import minimize from scipy.optimize before using it.

4

Print the optimal solution and profit

Print the optimal units of product A and product B from result.x with labels. Then print the maximum profit by negating result.fun.

SciPy

from scipy.optimize import minimize

def profit(x):
    return -(40 * x[0] + 30 * x[1])

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

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

constraints = [
    {'type': 'ineq', 'fun': constraint1},
    {'type': 'ineq', 'fun': constraint2}
]

result = minimize(profit, x0=[0, 0], method='SLSQP', constraints=constraints)

# Print the optimal units for product A and B
# Print the maximum profit
# Your code here

Hint

Use result.x for units and -result.fun for profit. Format numbers to two decimals.

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