Python优化中使用拉格朗日法求解不等式约束问题时如何获取Lambda值

Absolutely! You can definitely get the values of λ₁ and λ₂—they’re already calculated by Scipy’s minimize function, you just need to extract them correctly from the result object. Let’s walk through how to adjust your code and understand what’s happening.

Key Background #

Your code uses SymPy to define the Lagrangian function for reference, but the actual optimization is handled by Scipy’s minimize tool. This tool automatically enforces the KKT conditions for constrained optimization, which include tracking the Lagrange multipliers for each inequality constraint.

Fixed & Annotated Code #

Here’s your updated code with comments explaining how to get λ₁ and λ₂:

import numpy as np
from scipy.optimize import minimize
from sympy import Symbol, Eq, display

# SymPy part: just for defining the Lagrangian (optional, for reference)
x1 = Symbol("x_1")
x2 = Symbol('x_2')
Z = Symbol("Z")
lamd1 = Symbol("\lambda_1")
lamd2 = Symbol("\lambda_2")
eq1 = Eq(Z, (x1-4)**2 + (x2-4)**2 + lamd1*(6 - 2*x1 - 3*x2) + lamd2*(-12 + 3*x1 + 2*x2))
display(eq1)

# Objective function
def f(x):
    return ((x[0] - 4)**2 + (x[1] - 4)**2)

# Define inequality constraints (each maps to one Lagrange multiplier)
cons = (
    {'type': 'ineq', 'fun': lambda x: 2*x[0] + 3*x[1] - 6},  # Corresponding to λ₁: 2x₁ + 3x₂ ≥ 6
    {'type': 'ineq', 'fun': lambda x: -3*x[0] - 2*x[1] + 12} # Corresponding to λ₂: 3x₁ + 2x₂ ≤ 12
)

# Initial guess: only needs x1 and x2 (no need to include λ values here!)
x0 = np.array([2, 2])
res = minimize(f, x0, constraints=cons)

# Extract Lagrange multipliers (matches the order of your constraints)
lambda1 = res.ineq_multipliers[0]
lambda2 = res.ineq_multipliers[1]

# Print results
print(f"Optimal x₁: {res.x[0]:.4f}, x₂: {res.x[1]:.4f}")
print(f"Lagrange multiplier λ₁: {lambda1:.4f}, λ₂: {lambda2:.4f}")
print("\nFull optimization result:")
print(res)

Critical Notes #

1. Fix the Initial Guess: Your original x0 = np.array([2,2,1]) included an extra value—initial guesses only need to cover your optimization variables (x1 and x2), not the Lagrange multipliers.
2. Multiplier Order Matters: The ineq_multipliers attribute in the result stores values in the exact same order as you defined your constraints in cons. So the first constraint’s multiplier is res.ineq_multipliers[0] (λ₁), and the second is res.ineq_multipliers[1] (λ₂).
3. KKT Condition Check: Remember the complementary slackness rule for KKT conditions:
   • If a constraint is active (i.e., the constraint holds with equality at the optimal solution), its corresponding multiplier will be positive.
   • If a constraint is inactive (the inequality is strict at the optimal solution), its multiplier will be 0.
     You can verify this by evaluating your constraint functions at res.x!

Bonus: Solving with SymPy Directly #

If you want to solve the KKT conditions symbolically (instead of using Scipy’s numerical solver), you can use SymPy to set up and solve the system of equations:

from sympy import solve

# Compute partial derivatives of the Lagrangian
dZ_dx1 = eq1.rhs.diff(x1)
dZ_dx2 = eq1.rhs.diff(x2)

# Define all KKT conditions: partial derivatives = 0, complementary slackness, constraints, non-negative multipliers
kkt_conditions = [
    Eq(dZ_dx1, 0),
    Eq(dZ_dx2, 0),
    Eq(lamd1*(6 - 2*x1 - 3*x2), 0),  # Complementary slackness for λ₁
    Eq(lamd2*(-12 + 3*x1 + 2*x2), 0), # Complementary slackness for λ₂
    6 - 2*x1 - 3*x2 <= 0,  # Equivalent to 2x₁ + 3x₂ ≥ 6
    -12 + 3*x1 + 2*x2 <= 0, # Equivalent to 3x₁ + 2x₂ ≤ 12
    lamd1 >= 0,
    lamd2 >= 0
]

# Solve the system
solutions = solve(kkt_conditions, (x1, x2, lamd1, lamd2), dict=True)

# Print all valid solutions
for idx, sol in enumerate(solutions):
    print(f"\nSolution {idx+1}:")
    print(f"x₁ = {sol[x1]}, x₂ = {sol[x2]}")
    print(f"λ₁ = {sol[lamd1]}, λ₂ = {sol[lamd2]}")

This will give you all symbolic solutions that satisfy the KKT conditions, and you can pick the one that minimizes your objective function.

内容的提问来源于stack exchange，提问作者Tatanik501