Constrained optimization in SciPy - Mini Project: Build & Apply

Constrained Optimization with SciPy

📖 Scenario: Imagine you are managing a small factory that produces two products: chairs and tables. You want to maximize your profit, but you have limited resources like wood and labor hours. You need to find the best number of chairs and tables to produce without exceeding your resource limits.

🎯 Goal: You will build a program that uses constrained optimization to find the number of chairs and tables to produce that maximizes profit while respecting resource limits.

📋 What You'll Learn

Create a function to calculate total profit based on quantities of chairs and tables

Set up constraints for wood and labor availability

Use SciPy's optimization function to find the best production plan

Print the optimal number of chairs and tables and the maximum profit

💡 Why This Matters

🌍 Real World

Factories and businesses often need to decide how much of each product to make to maximize profit without wasting resources.

💼 Career

Understanding constrained optimization is useful for roles in operations research, data science, and business analytics to make smart decisions.

1

Create the profit function

Create a function called profit that takes a list x with two elements: the number of chairs (x[0]) and tables (x[1]). The function should return the total profit calculated as 50 * x[0] + 80 * x[1].

SciPy

# Your code here

Hint

Use def to create the function and return the sum of profits for chairs and tables.

2

Set up resource constraints

Create a list called constraints with two dictionaries. The first dictionary should have 'type': 'ineq' and a 'fun' key with a lambda function that returns 100 - (5 * x[0] + 10 * x[1]) representing the wood limit. The second dictionary should have 'type': 'ineq' and a 'fun' key with a lambda function that returns 80 - (2 * x[0] + 4 * x[1]) representing the labor limit.

SciPy

def profit(x):
    return 50 * x[0] + 80 * x[1]

# Your code here

Hint

Use a list of dictionaries with 'type': 'ineq' and lambda functions for constraints.

3

Use SciPy to find the optimal solution

Import minimize from scipy.optimize. Use minimize with the function lambda x: -profit(x), initial guess [0, 0], and the constraints list. Save the result in a variable called result.

SciPy

def profit(x):
    return 50 * x[0] + 80 * x[1]

constraints = [
    {'type': 'ineq', 'fun': lambda x: 100 - (5 * x[0] + 10 * x[1])},
    {'type': 'ineq', 'fun': lambda x: 80 - (2 * x[0] + 4 * x[1])}
]

# Your code here

Hint

Remember to import minimize and use a lambda to minimize the negative profit.

4

Print the optimal production and profit

Print the optimal number of chairs and tables from result.x rounded to 2 decimals. Then print the maximum profit by calling profit with result.x rounded to 2 decimals.

SciPy

from scipy.optimize import minimize

def profit(x):
    return 50 * x[0] + 80 * x[1]

constraints = [
    {'type': 'ineq', 'fun': lambda x: 100 - (5 * x[0] + 10 * x[1])},
    {'type': 'ineq', 'fun': lambda x: 80 - (2 * x[0] + 4 * x[1])}
]

result = minimize(lambda x: -profit(x), [0, 0], constraints=constraints)

# Your code here

Hint

Use round() to limit decimals and print() to show results.

Practice

1. What is the main purpose of constrained optimization in scipy.optimize.minimize?

easy

A. To only check if constraints are valid

B. To find any random solution without restrictions

C. To find the best solution while respecting given limits or rules

D. To maximize the function without any constraints

Solution

1. Step 1: Understand constrained optimization goal

   Constrained optimization aims to find the best (minimum or maximum) value of a function while following certain limits or rules called constraints.

2. Step 2: Relate to scipy.optimize.minimize usage

   The minimize function in scipy can include constraints and bounds to ensure the solution respects these limits.

3. Final Answer:

   To find the best solution while respecting given limits or rules -> Option C

4. Quick Check:

   Constrained optimization = best solution within limits [OK]

Hint: Constrained means limits must be followed [OK]

Common Mistakes:

• Thinking constraints are optional or ignored
• Confusing constrained with unconstrained optimization
• Assuming constraints only check validity, not guide solution

2. Which of the following is the correct way to define the inequality constraint `x[0] >= 1` for scipy.optimize.minimize?

easy

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

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

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

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

Solution

1. Step 1: Recall inequality constraint definition

   Inequality constraints require the function to be >= 0. So, fun(x) >= 0 means the constraint holds.

2. Step 2: Check each option

   constraint = {'type': 'ineq', 'fun': lambda x: x[0] - 1}: lambda x: x[0] - 1 means x[0] - 1 >= 0 or x[0] >= 1, correct for the constraint.
   Options B and D use 'eq' which means equality, not inequality.
   constraint = {'type': 'ineq', 'fun': lambda x: 1 - x[0]} means 1 - x[0] >= 0 or x[0] <= 1, which is a different constraint.

3. Final Answer:

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

4. Quick Check:

   Inequality means fun(x) >= 0 [OK]

Hint: Inequality means function output ≥ 0 [OK]

Common Mistakes:

• Using 'eq' instead of 'ineq' for inequalities
• Reversing the inequality sign in the function
• Confusing the function output sign for constraints

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

from scipy.optimize import minimize

fun = lambda x: (x[0]-2)**2 + (x[1]-3)**2
cons = ({'type': 'eq', 'fun': lambda x: x[0] + x[1] - 5})
res = minimize(fun, [0, 0], constraints=cons)
print(res.x.round(2))

medium

A. [2.5 2.5]

B. [1.0 4.0]

C. [0.0 5.0]

D. [2.0 3.0]

Solution

1. Step 1: Understand the objective and constraint

   The function minimizes distance from point (2,3). The constraint requires x[0] + x[1] = 5.

2. Step 2: Find point on line x0+x1=5 closest to (2,3)

   We want to minimize (x0-2)^2 + (x1-3)^2 with x0+x1=5. Using substitution: x1=5-x0.
   Objective becomes (x0-2)^2 + (5-x0-3)^2 = (x0-2)^2 + (2 - x0)^2.
   Expanding: (x0-2)^2 + (2-x0)^2 = 2*(x0-2)^2.
   Minimum at x0=2, then x1=3, which satisfies the constraint.

3. Step 3: Check options

   [2.0 3.0] matches the minimum (2.0, 3.0). [1.0 4.0] sums to 5 but is farther from (2,3). The solver converges to [2.0, 3.0].

4. Final Answer:

   [2.0 3.0] -> Option D

5. Quick Check:

   Minimum at (2,3) on constraint line [OK]

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

Common Mistakes:

• Ignoring the constraint when finding minimum
• Confusing initial guess with solution
• Assuming solver returns initial guess

4. Identify the error in this constrained optimization code:

from scipy.optimize import minimize

fun = lambda x: x[0]**2 + x[1]**2
cons = [{'type': 'ineq', 'fun': lambda x: x[0] + x[1] - 1}]
res = minimize(fun, [0, 0], constraints=cons)
print(res.x)

medium

A. Initial guess violates the inequality constraint

B. Constraint function should return negative values

C. Constraints must be a dictionary, not a list

D. Objective function must be linear

Solution

1. Step 1: Check initial guess against constraint

   The inequality constraint requires x[0] + x[1] - 1 >= 0, or x[0] + x[1] >= 1.
   The initial guess is [0,0], sum is 0, which violates the constraint.

2. Step 2: Understand impact of violating initial guess

   Starting from a point that violates constraints can cause solver to fail or give warnings.
   Other options are incorrect because:
   - Constraint function should return >=0 for valid points.
   - Constraints can be a list of dicts.
   - Objective function can be nonlinear.

3. Final Answer:

   Initial guess violates the inequality constraint -> Option A

4. Quick Check:

   Initial guess must satisfy constraints [OK]

Hint: Check if initial guess meets constraints [OK]

Common Mistakes:

• Ignoring initial guess validity
• Misunderstanding constraint function sign
• Thinking constraints must be single dict

5. You want to minimize f(x) = (x[0]-1)^2 + (x[1]-2)^2 with constraints x[0] >= 0, x[1] >= 0, and x[0] + 2*x[1] = 3. Which setup correctly applies these constraints using scipy.optimize.minimize?

hard

A. bounds = [(0, None), (0, None)]; cons = {'type': 'eq', 'fun': lambda x: x[0] + 2*x[1] - 3}

B. bounds = [(None, 0), (None, 0)]; cons = {'type': 'ineq', 'fun': lambda x: 3 - x[0] - 2*x[1]}

C. bounds = [(0, None), (0, None)]; cons = {'type': 'ineq', 'fun': lambda x: x[0] + 2*x[1] - 3}

D. bounds = [(0, None), (0, None)]; cons = {'type': 'ineq', 'fun': lambda x: 3 - x[0] - 2*x[1]}

Solution

1. Step 1: Set bounds for inequalities

   Constraints x[0] >= 0 and x[1] >= 0 are bounds: [(0, None), (0, None)] means lower bound 0, no upper bound.

2. Step 2: Define equality constraint

   The equality x[0] + 2*x[1] = 3 is expressed as fun(x) = x[0] + 2*x[1] - 3 = 0 with type 'eq'.

3. Step 3: Check options

   bounds = [(0, None), (0, None)]; cons = {'type': 'eq', 'fun': lambda x: x[0] + 2*x[1] - 3} correctly sets bounds and equality constraint.
   bounds = [(None, 0), (None, 0)]; cons = {'type': 'ineq', 'fun': lambda x: 3 - x[0] - 2*x[1]} reverses bounds and uses inequality instead of equality.
   bounds = [(0, None), (0, None)]; cons = {'type': 'ineq', 'fun': lambda x: x[0] + 2*x[1] - 3} uses inequality for equality constraint.
   bounds = [(0, None), (0, None)]; cons = {'type': 'ineq', 'fun': lambda x: 3 - x[0] - 2*x[1]} uses inequality (x[0] + 2*x[1] <= 3) instead of equality.

4. Final Answer:

   bounds = [(0, None), (0, None)]; cons = {'type': 'eq', 'fun': lambda x: x[0] + 2*x[1] - 3} -> Option A

5. Quick Check:

   Bounds for inequalities + 'eq' for equality [OK]

Hint: Use bounds for ≥ constraints, 'eq' for equalities [OK]

Common Mistakes:

• Using 'ineq' for equality constraints
• Reversing bounds limits
• Confusing constraint function sign