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：

最小化：c ^ T * x

受制于：

A_ub * x＆lt; = 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（唯一可能的值）。

线性编程，具有等式约束的意外解决方案

2 个答案: