Question

我遇到LP问题。在解释问题之前，我将首先尝试以简化的方式解释问题。

基本问题

假设我有三种类型的机器，所有这些机器只能运行两个时间段（T1，T2，T3或T4），如下面矩阵中所示。

Machine T1    T2    T3   T4    Amount 
M1      0     1     1    0     x1     
M2      1     1     0    0     x2     
M3      0     0     1    1     x3

每台机器都可以生成任意数量的物品（x1到x3;变量）。这是每个时间段实现MIMINUM所需生产所必需的：

            T1  T2  T3  T4
Required    2   3   1   1

要解决这个问题，我们需要：

M2生成2，
M3生成1，
M1或M2产生1，效果是分别在T3或T1产生太多。

可能导致：

Machine T1    T2    T3   T4    Amount 
M1      0     0     0    0     0     
M2      3     3     0    0     3     
M3      0     0     1    1     1      

prod    3     3     1    1
Requ    2     3     1    1

约束

T1和T4期间的生产不是优选的，应该受到惩罚。在上面的示例中，这意味着应该使用M1来生成。

在简单的措辞中，问题表明至少产生所需的数量，但最大限度地减少任何过量（特别是在T1和T4中）。

这可以通过两种方式完成：

在这些时期运作的机器将受到惩罚（M处罚; M2和M3）。
每个时间段的生产受到惩罚（由T处罚; T1和T4）

这看起来如下：

Machine T1    T2    T3   T4    Amount   Pm
M1      0     1     1    0     x1       0
M2      1     1     0    0     x2       0.5
M3      0     0     1    1     x3       0.5

Pt      0.5   0     0    0.5

问题：我只能让每台机器受到惩罚才能正常工作。按时间处罚不是不可行的，但是输出不正确（冗余机器太多）。

尝试和结果

我首先用m（Pm）惩罚解算器。这里的目标函数（在Python纸浆中）是：

amount = LpVariable.dicts("amount_",Machine,0,100000,LpInteger)
product_t = LpVariable.dicts("product_",time,0,100000,LpInteger)


prob += lpSum([amount[m]*(1+Pm[m]) for m in Machine]) # minimize

# constraint
for t in time:
    # production per time period; matrix[m,t] is the matrix with ones shown above
    product_t[t] = lpSum([amount[m] * matrix[m,t] for m in machine])
    # production must be higher than required. 
    prob += product_t[t] >= req[t]

这种情况的结果将是（机器，生产，惩罚）： M1 * 1 * (0+1) + M2 * 2 * (0.5+1) + M3 * 1 * (0.5+1) = 5.5与次优解决方案进行比较：M1 * 0 * (0+1) + M2 * 3 * (0.5+1) + M3 * 1 * (0.5+1) = 6

接下来，因为这种方法在实际情况中有一些缺点，我想用t（Pt）来惩罚它。

prob += lpSum([product_t[t]*(1+Pt[t]) for t in time]) #minimize

for t in time:  # same calculation of product_t and constraint as above
    product_t[t] = lpSum([amount[m] * matrix[m,t] for m in machine])
    prob += inzet_t[t] >= nodig[t]

然而，这种方法给了我一个可行但不正确的输出（产量= 0.0）。

问题

在完全相同的约束条件下，按时间惩罚不起作用怎么可能？不允许目标函数包含变量（product_t）约束

Answer 1

我开始越来越多地讨论代码并发现以下内容： amount和product_t的定义方式相同。但是，可以说amount[m].varValue，但说product_t[t].varValue不是（LpAffineExpression没有名为varValue的属性）。相反，我不得不说value(product_t[t])。我认为这是因为amount用于计算product_t，因此product_t是一种不同的变量。所以我知道我必须在目标公式中使用product_t

尝试1：失败，但这是一个长期的

prob +=  lpSum([value(product_t[t])*Pt[t] for t in time  ]) #added value() 
# Error: Unsupported operant * for NoneType and float`

尝试2：取得了成功。

在目标函数prob += lpSum([product_t[t]*(1+Pt[t]) for t in time]) #minimize中，我用公式替换了product_t来计算它。所以，目标函数是：

prob += lpSum([product_t[t]*(1+Pt[t]) for t in time]) #OLD

并成为

prob += lpSum([lpSum([amount[i] * timeblock_matrix[i,t] for i in dienst])*Pt[t] for t in time]) #NEW, minimize

如果有人可以解释为什么它的工作原理，为什么它不能有一个中间的LpVariable，那将非常感激。

Answer 2

据我所知，你的问题是

<强>集：

M = {m1, m2, m3}台机器
T = {t1, t2, t3, t4}时间段

决策变量：

p[m,t]二进制：机器m是否在时间段t内运作？

<强>约束：

最低生产量：在您提出的要求的问题中
- sum_m(t1)=2
- sum_m(t2)=3
- sum_m(t3)=1
- sum_m(t4)=1
最长运营时间
- sum_t(m1)=2
- sum_t(m2)=2
- sum_t(m3)=2

<强>目标

min C sum_m(t1)+sum_m(t2)+sum_m(t3)+C sum_m(t4)，其中C>1在第一个或最后一个时间段内受到处罚。

我认为如果您同意这可以解决您的问题，那么应该可以将此模型转移到代码中。

线性规划：客观变量能否有约束？

问题

2 个答案: