线性规划，具有等式约束的意外解

Question

我想弄清楚我的实现有什么问题，我希望结果是 [5, 10]，我不明白它是如何得到的 [7.5, 7.5]、x1应该是 x2.

的一半

from scipy.optimize import linprog
import numpy as np

c = [-1, -1]

A_eq = np.array([
    [1, 0.5],
    [1, -0.5],
])

b_eq = [15, 0]

x0_bounds = (0, None)
x1_bounds = (0, None)

res = linprog(
    c,
    A_eq=A_eq.transpose(),
    b_eq=b_eq,
    bounds=(x0_bounds, x1_bounds),
    options={"disp": True})

print res.x
# =>                                                                                                                                                                                 
# Optimization terminated successfully.                                                                                                                                              
#          Current function value: -15.000000                                                                                                                                        
#          Iterations: 2                                                                                                                                                             
# [ 7.5  7.5]

作者更新：

据说这里不需要矩阵转置。问题出在矩阵本身，为了得到想要的结果，即 [5, 10]，它必须是：

A_eq = np.array([
    [1, 1],
    [1, -0.5],
])

Answer 1

根据 scipy linprog docs:

Minimize: c^T * x

Subject to:

A_ub * x <= b_ub

A_eq * x == b_eq

因此，您现在正在求解以下方程式：

Minimize -x1 -x2

受制于，*

x1 + x2 = 15 (i)
0.5 * x1 - 0.5 * x2 = 0 (ii)

现在，(ii) 暗示 x1 = x2（因此您想要的解决方案不可行），然后 (i) 修正 x1 = x2 = 7.5。所以，linprog()返回的解确实是正确的。由于您期望不同的结果，也许您应该研究将问题转化为代码的方式，因为我认为这就是您可以找到问题和解决方案的地方。

*) 因为你正在进行转置。

Answer 2

您的问题是：

x1 + x2 == 15
0.5 * x1 - 0.5 * x2 == 0

minimize -x1 -x2

显然你有 x1 == x2（第二个约束），因此 x1 = x2 = 7.5（第一个约束）。

看你的问题，你可能不想转置A:

res = linprog(
    c,
    A_eq=A_eq,
    b_eq=b_eq,
    bounds=(x0_bounds, x1_bounds),
    options={"disp": True}
)

为什么给你这个问题：

x1 + 0.5 * x2 == 15
x1 - 0.5 * x2 == 0

minimize -x1 -x2

你得到 x1 = 7.5 和 x2 = 15（唯一可能的值）。

线性规划，具有等式约束的意外解

Linear programming, unexpected solution with equality constraint

python

scipy

linear-programming