Question $$ 3(3 \%) $$ For question one above, suppose Plants 2 and 3 were decommissioned and replaced with an updated facility. The production capacity of this new Plant is constrained by the following equation: $$ 9\left(x_{1}\right)^{2}+5\left(x_{2}\right)^{2} \leq 216 $$. (a) Write a mathematical model for the updated optimization problem (remember now there are only Plant 1 and the new Plant). (Hand written submission) (b) Write a PyTorch's program that uses gradient descent to solve (a). Submit a single python file (no notebooks). The file extension is . Py.

Question

UpStudy AI · Accepted Answer

Below is one acceptable answer. (Any mathematically equivalent formulation is correct.)

───────────────────────────────────────────── 
Example Answer (a):

Suppose that in “Question One” the decision was to choose the production quantities at three plants. Now Plants 2 and 3 have been replaced by one “updated” facility. Let

x₁ = production quantity at Plant 1  
  x₂ = production quantity at the new facility

Also assume that the original objective function was, for example, to maximize profit given by

maximize 20x₁ + 15x₂

(with the “20” and “15” being the per‐unit contribution to profit from the two plants; note that other objective functions are acceptable so long as the original model’s intent is preserved).

In the updated problem the only production capacity constraint is that of the new facility which has a “quadratic” capacity restriction. (For example, one might imagine that the available resources in the updated machine have a quadratic relation to a decision variable.) In particular, its capacity is given by

9x₁² + 5x₂² ≤ 216

Finally, we normally require nonnegativity conditions:

x₁ ≥ 0, x₂ ≥ 0

Thus, one acceptable mathematical model is

maximize 20x₁ + 15x₂  
  subject to 9x₁² + 5x₂² ≤ 216  
       x₁, x₂ ≥ 0

(If your original problem had a different objective, you should replace the objective accordingly.)

───────────────────────────────────────────── 
Example Answer (b):

One way to solve the above problem by gradient descent in PyTorch is to “penalize” any violation of the constraint. (Other methods – such as using projections – are also acceptable.) For example, we can transform the constrained maximization into an unconstrained minimization by “penalizing” any violation of 9x₁²+5x₂² ≤ 216. (Since gradient descent minimizes, we will minimize the negative profit plus a penalty term.)

Below is one complete Python (.py) file that does this. (Note: We assume that one wishes to “maximize profit”. If you are minimizing cost, then you would of course change the signs accordingly.)

───────────────────────────────────────────── 
# Begin file: optimize_production.py

import torch

def main():
    # Choose a value for the penalty parameter
    penalty_weight = 1000.0
    
    # Set up our "profit" coefficients (as in part (a))
    p1 = 20.0
    p2 = 15.0

# We work with a two-dimensional variable (x1, x2)
    # Initialize with a feasible guess. Here, we choose x1=1, x2=1.
    x = torch.tensor([1.0, 1.0], requires_grad=True)

# Set up the optimizer. (Using a small learning rate may be necessary.)
    optimizer = torch.optim.SGD([x], lr=0.001)
    
    # Run the gradient descent for a number of iterations.
    num_iters = 5000
    for i in range(num_iters):
        optimizer.zero_grad()
        
        # The (negative) objective function (since we want to maximize profit).
        # In our unconstrained formulation, we minimize: 
        #     loss = -profit + penalty
        profit = p1 * x[0] + p2 * x[1]
        # Compute violation of the capacity constraint: 9*x1^2 + 5*x2^2 <= 216.
        # We use a penalty term that is zero if the constraint is satisfied.
        constraint_violation = 9*x[0]**2 + 5*x[1]**2 - 216.0
        penalty = penalty_weight * torch.relu(constraint_violation)**2
        
        # The total loss (we want to minimize this quantity).
        loss = -profit + penalty
        
        # Perform backpropagation and a gradient descent step.
        loss.backward()
        optimizer.step()
        
        # Optionally, one might enforce nonnegativity by projection.
        with torch.no_grad():
            x.clamp_(min=0.0)
        
        # For monitoring, print every 500 iterations.
        if i % 500 == 0:
            print(f"Iter {i:4d}: x = {x.detach().numpy()}, profit = {profit.item():.4f}, loss = {loss.item():.4f}")

# After the loop, report the final solution.
    print("Final solution:")
    print("x1 =", x[0].item(), "x2 =", x[1].item())
    print("Profit =", (p1*x[0] + p2*x[1]).item())
    # Check the constraint:
    constraint_value = 9*x[0]**2 + 5*x[1]**2
    print("Constraint (should be <= 216):", constraint_value.item())

if __name__ == '__main__':
    main()
    
# End file: optimize_production.py
─────────────────────────────────────────────

Explanation:

1. We define our decision variables x₁ and x₂ (stored in a torch tensor x) with the gradient tracker on.
2. Our “loss” is the negative profit (because we are maximizing profit) plus a quadratic penalty that “activates” only when 9x₁²+5x₂²–216 is positive (i.e. when the capacity constraint is violated). 
3. We use torch.optim.SGD with a small learning rate. (Other optimizers such as Adam are acceptable.)
4. We optionally enforce nonnegativity with x.clamp_(min=0.0).
5. The code prints the solution every 500 iterations and a final report at the end.

Any implementation that correctly uses gradient descent (with the proper handling of the constraint) to solve the optimization problem is acceptable.

───────────────────────────────────────────── 
This completes an acceptable answer to both parts (a) and (b).
(a) Mathematical Model: - **Objective**: Maximize profit $$ 20x₁ + 15x₂ $$ - **Constraints**: - $$ 9x₁² + 5x₂² \leq 216 $$ - $$ x₁ \geq 0 $$, $$ x₂ \geq 0 $$ (b) PyTorch Gradient Descent Program: ```python import torch def main(): penalty_weight = 1000.0 p1, p2 = 20.0, 15.0 x = torch.tensor([1.0, 1.0], requires_grad=True) optimizer = torch.optim.SGD([x], lr=0.001) num_iters = 5000 for i in range(num_iters): optimizer.zero_grad() profit = p1 * x[0] + p2 * x[1] constraint_violation = 9*x[0]**2 + 5*x[1]**2 - 216.0 penalty = penalty_weight * torch.relu(constraint_violation)**2 loss = -profit + penalty loss.backward() optimizer.step() x.clamp_(min=0.0) if i % 500 == 0: print(f"Iter {i:4d}: x = {x.detach().numpy()}, profit = {profit.item():.4f}, loss = {loss.item():.4f}") print("Final solution:") print("x1 =", x[0].item(), "x2 =", x[1].item()) print("Profit =", (p1*x[0] + p2*x[1]).item()) print("Constraint:", 9*x[0]**2 + 5*x[1]**2) if __name__ == '__main__': main() ``` This program uses gradient descent to find the optimal production quantities for Plant 1 and the new facility while respecting the capacity constraint.

Upstudy AI Solution

Answer

Solution

The Deep Dive

Related Questions

Latest Other Questions