Bounds and constraints in SciPy - Mini Project: Build & Apply

Bounds and Constraints in Optimization with SciPy

📖 Scenario: You are working as a data scientist helping a company optimize their product pricing to maximize profit. The prices must stay within certain limits, and some relationships between prices must hold true.

🎯 Goal: Build a Python program using SciPy to find the best prices for two products that maximize profit, while respecting given bounds and constraints.

📋 What You'll Learn

Create a function to calculate profit based on product prices

Set bounds for product prices

Add a constraint that one product price must be at least 1.5 times the other

Use SciPy's minimize function with bounds and constraints

Print the optimized product prices and maximum profit

💡 Why This Matters

🌍 Real World

Companies often need to find the best prices for products to maximize profit while respecting market or production limits.

💼 Career

Understanding how to apply bounds and constraints in optimization is key for data scientists working in pricing, operations, and resource allocation.

1

Create the profit function

Create a function called profit that takes a list prices with two elements: price of product A and price of product B. The function should return the total profit calculated as 5 * prices[0] + 3 * prices[1] minus the cost 2 * prices[0] + prices[1].

SciPy

# Define the profit function
# Your code here

Hint

Use def profit(prices): to define the function and return the profit formula.

2

Set bounds for product prices

Create a variable called bounds that sets the price of product A between 1 and 10, and the price of product B between 2 and 8. Use a list of tuples for the bounds.

SciPy

def profit(prices):
    return 5 * prices[0] + 3 * prices[1] - (2 * prices[0] + prices[1])

# Set bounds for prices
# Your code here

Hint

Use a list of tuples like [(1, 10), (2, 8)] to set bounds for each product price.

3

Add constraint and optimize

Create a dictionary called constraint with key type set to 'ineq' and key fun set to a lambda function that takes prices and returns prices[0] * 1.5 - prices[1]. Then, use scipy.optimize.minimize to minimize the negative profit function starting from initial prices [2, 3], with the bounds and constraints set to a list containing constraint. Store the result in result. Remember to import minimize from scipy.optimize. Negate the profit function by defining neg_profit = lambda prices: -profit(prices).

SciPy

def profit(prices):
    return 5 * prices[0] + 3 * prices[1] - (2 * prices[0] + prices[1])

bounds = [(1, 10), (2, 8)]

# Import minimize and set constraint
# Your code here

Hint

Use constraint = {'type': 'ineq', 'fun': lambda prices: prices[0] * 1.5 - prices[1]} and call minimize with neg_profit, initial guess, bounds, and constraints.

4

Print optimized prices and profit

Print the optimized prices from result.x with the message "Optimized prices:". Then print the maximum profit by calling profit with result.x and the message "Maximum profit:".

SciPy

from scipy.optimize import minimize

def profit(prices):
    return 5 * prices[0] + 3 * prices[1] - (2 * prices[0] + prices[1])

bounds = [(1, 10), (2, 8)]

constraint = {'type': 'ineq', 'fun': lambda prices: prices[0] * 1.5 - prices[1]}

neg_profit = lambda prices: -profit(prices)

result = minimize(neg_profit, [2, 3], bounds=bounds, constraints=[constraint])

# Print optimized prices and maximum profit
# Your code here

Hint

Use print("Optimized prices:", result.x) and print("Maximum profit:", profit(result.x)).

Practice

1. What is the main purpose of bounds in scipy.optimize functions?

easy

A. To set the maximum number of iterations

B. To define the objective function to minimize

C. To limit the range of values each variable can take

D. To specify the initial guess for variables

Solution

1. Step 1: Understand the role of bounds

   Bounds restrict each variable to a specific range, for example, between 0 and 1.

2. Step 2: Differentiate bounds from other parameters

   Bounds are not about the objective function, initial guess, or iteration limits; they only limit variable values.

3. Final Answer:

   To limit the range of values each variable can take -> Option C

4. Quick Check:

   Bounds = variable limits [OK]

Hint: Bounds always restrict variable ranges, not function or iterations [OK]

Common Mistakes:

• Confusing bounds with constraints
• Thinking bounds set initial guesses
• Assuming bounds limit iterations

2. Which of the following is the correct way to define bounds for two variables x and y where x is between 0 and 5, and y is between -1 and 1 in scipy.optimize.minimize?

easy

A. bounds = [(0, 5), (-1, 1)]

B. bounds = {0:5, -1:1}

C. bounds = [0, 5, -1, 1]

D. bounds = (0, 5, -1, 1)

Solution

1. Step 1: Recall bounds format in scipy.optimize

   Bounds are given as a list of tuples, each tuple for one variable's (min, max).

2. Step 2: Check each option's format

   bounds = [(0, 5), (-1, 1)] uses a list of tuples correctly. Options A (flat list), B (dictionary), and D (flat tuple) are invalid formats.

3. Final Answer:

   bounds = [(0, 5), (-1, 1)] -> Option A

4. Quick Check:

   Bounds = list of (min, max) tuples [OK]

Hint: Use list of (min, max) tuples for bounds [OK]

Common Mistakes:

• Using dictionary instead of list
• Passing flat list instead of tuples
• Confusing tuple and list syntax

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

from scipy.optimize import minimize

func = lambda x: (x[0]-1)**2 + (x[1]+2)**2
bounds = [(0, 2), (-3, -1)]
result = minimize(func, x0=[0, 0], bounds=bounds)
print(result.x)

medium

A. [0.5 -1.5]

B. [0. -3.]

C. [2. -1.]

D. [1. -2.]

Solution

1. Step 1: Understand the objective function and bounds

   The function is minimized when x[0] = 1 and x[1] = -2. Bounds allow x[0] between 0 and 2, and x[1] between -3 and -1.

2. Step 2: Check if the minimum is within bounds

   Since (1, -2) is inside the bounds, the optimizer will find this point.

3. Final Answer:

   [1. -2.] -> Option D

4. Quick Check:

   Minimum inside bounds = [1, -2] [OK]

Hint: Minimum inside bounds is the solution [OK]

Common Mistakes:

• Ignoring bounds and picking unconstrained minimum
• Confusing bounds order
• Assuming initial guess is final answer

4. Identify the error in the following code that uses bounds in scipy.optimize.minimize:

from scipy.optimize import minimize

func = lambda x: x[0]**2 + x[1]**2
bounds = [0, 1, 0, 1]
result = minimize(func, x0=[0.5, 0.5], bounds=bounds)
print(result.x)

medium

A. Initial guess x0 is outside bounds

B. Bounds should be a list of tuples, not a flat list

C. Objective function must return a scalar

D. Bounds must be specified as a dictionary

Solution

1. Step 1: Check bounds format

   The code uses bounds = [0, 1, 0, 1], which is a flat list. scipy expects a list of tuples for bounds.

2. Step 2: Confirm other parameters

   Initial guess is inside bounds, function returns scalar, and bounds as dictionary is not required.

3. Final Answer:

   Bounds should be a list of tuples, not a flat list -> Option B

4. Quick Check:

   Bounds = list of tuples, not flat list [OK]

Hint: Use list of tuples for bounds, not flat list [OK]

Common Mistakes:

• Using flat list instead of list of tuples
• Setting initial guess outside bounds
• Misunderstanding bounds format

5. You want to minimize the function f(x, y) = (x-3)^2 + (y+1)^2 with the constraints that x + y = 2 and bounds 0 ≤ x ≤ 4, -2 ≤ y ≤ 2. Which of the following correctly sets up the constraints and bounds for scipy.optimize.minimize?

hard

A. constraints = {'type': 'eq', 'fun': lambda v: v[0] + v[1] - 2}; bounds = [(0, 4), (-2, 2)]

B. constraints = [{'type': 'ineq', 'fun': lambda v: v[0] + v[1] - 2}]; bounds = [(0, 4), (-2, 2)]

C. constraints = {'type': 'eq', 'fun': lambda v: v[0] - v[1] - 2}; bounds = [(0, 4), (-2, 2)]

D. constraints = [{'type': 'eq', 'fun': lambda v: v[0] + v[1] - 2}]; bounds = [(0, 2), (-2, 2)]

Solution

1. Step 1: Define the equality constraint

   The constraint is x + y = 2, so the function should return zero when this holds: lambda v: v[0] + v[1] - 2. It must be an equality constraint ('eq').

2. Step 2: Set the correct bounds

   Bounds are 0 ≤ x ≤ 4 and -2 ≤ y ≤ 2, so bounds = [(0, 4), (-2, 2)].

3. Final Answer:

   constraints = {'type': 'eq', 'fun': lambda v: v[0] + v[1] - 2}; bounds = [(0, 4), (-2, 2)] -> Option A

4. Quick Check:

   Equality constraint + correct bounds = constraints = {'type': 'eq', 'fun': lambda v: v[0] + v[1] - 2}; bounds = [(0, 4), (-2, 2)] [OK]

Hint: Equality constraint returns zero when condition met [OK]

Common Mistakes:

• Using inequality instead of equality constraint
• Swapping bounds limits
• Incorrect constraint function expression