1

我正在使用 PYOMO，我想在“P_constraint_rule”中实现逻辑或，但我做不到。

我的模型有一些部分：

model.s = Param(within=NonNegativeIntegers)
model.S = RangeSet(1, model.s)
model.f = Param(within=NonNegativeIntegers)
model.F = RangeSet(1, model.f)
model.p = Param(within=NonNegativeIntegers)
model.P = RangeSet(0, model.p)
model.m = Param(within=NonNegativeIntegers)
model.M = RangeSet(1, model.m)
model.g = Param(model.M, default=5.0)
model.b2 = Param(model.F,model.F, within=Binary, default=0)
model.xf1f2 = Var(model.F, model.F, within=Binary)
model.y = Var(model.M, within=Binary)
model.xf = Var(model.F, within=Binary)
model.aff = Param(model.F,model.F, within=NonNegativeIntegers, default=0)

...

model.x = Var(model.index_sfpm, within=Binary)
model.b1 = Param(model.index_sfpm, within=Binary, default=0)


def Obj_rule(model):
    expr = 0.0
    for (s,f,p,m) in model.index_sfpm:
        expr += model.g[m] * model.xf[f] * model.b1[s,f,p,m] * model.x[s,f,p,m]    
    for m in model.M:
        expr += model.g[m] * model.y[m]

    return expr

model.OBJ = Objective(rule=Obj_rule, sense=maximize)


def P_constraint_rule (model, f1, f2):
    expr = 0.0
    for (s,m) in model.index_sm:
        expr += model.b2[f1,f2] * model.xf[f1] * model.b1[s,f1,1,m] * model.x[s,f1,1,m]
        expr += model.xf[f2] * model.b1[s,f2,1,m] * model.x[s,f2,1,m]

例如在我的 .dat 中：param aff:= 1 7 10

    return expr == model.aff[f1,f2] | expr == 0

model.PConstraint = Constraint(model.index_f1f2, rule=P_constraint_rule)

当我使用“|”时，出现以下错误：

ERROR: Rule failed when generating expression for constraint PConstraint with index (7, 3):
        TypeError: unsupported operand type(s) for |: 'int' and '_SumExpression' ERROR: Constructing component 'PConstraint' from data=None failed:
        TypeError: unsupported operand type(s) for |: 'int' and '_SumExpression' [    1.72] Pyomo Finished ERROR: Unexpected exception while running model:
        unsupported operand type(s) for |: 'int' and '_SumExpression'

当我使用“||”

ERROR: Unexpected exception while loading model:
        invalid syntax

当该约束被注释时，模型和 gurobi 运行良好。

有人可以帮助我解决这些错误吗？

还有另一种使用量词的可能性吗？不等式 P1.constraint 应该对 model.index_f1f2 有效 等式 P2Constraint 应该对 model.F 的 2 个元素或 model.index_f1f2 的 1 个元素有效，如下所示：

def P1_constraint_rule (model, f1, f2):
expr = 0.0
for (s,m) in model.index_sm:
    expr += model.b2[f1,f2] * model.xf[f1] * model.b1[s,f1,1,m] * model.x[s,f1,1,m]
    expr += model.xf[f2] * model.b1[s,f2,1,m] * model.x[s,f2,1,m]
return expr <= model.aff[f1,f2]

model.P1Constraint = Constraint(model.index_f1f2, rule=P1_constraint_rule)


def P2_constraint_rule (model, f1, f2):
    expr = 0.0
    for (s,m) in model.index_sm:
        expr += model.b2[f1,f2] * model.xf[f1] * model.b1[s,f1,1,m] * model.x[s,f1,1,m]
        expr += model.xf[f2] * model.b1[s,f2,1,m] * model.x[s,f2,1,m]
        #this equation should be valid for 2 elements of model.F or 1 element of model.index_f1f2
     return expr == model.aff[f1,f2]

model.P2Constraint = Constraint(model.index_f1f2, rule=P2_constraint_rule)

提前谢谢你，拉拉

4

2 回答 2

3

该错误是因为您试图指定非代数约束。从概念上讲，以下将定义逻辑析取：

expr == model.aff[f1,f2] | expr == 0

对于特定的句法问题：

  • |是二元或。它比关系运算符绑定得更紧密，因此不会做你想做的事。
  • ||不是有效的 Python 语法
  • 从概念上讲，您想要的是逻辑或，在 Python 中是用or. 这将是一个很好的支持语法 - 但是，Pyomo 目前不支持它。

您有两个选项来指定这样的约束：(1) 使用pyomo.gdp扩展将其指定为析取，然后利用转换pyomo.gdp将析取程序放宽回 MIP，或者 (2) 使用例如显式放宽析取，一个大 M 松弛。要执行前者，您需要定义两个析取词，然后定义析取词：

from pyomo.gdp import *

def P_disjunct_rule (b, f1, f2, i):
    model = b.model()
    expr = 0.0
    for (s,m) in model.index_sm:
        expr += model.b2[f1,f2] * model.xf[f1] * model.b1[s,f1,1,m] * model.x[s,f1,1,m]
        expr += model.xf[f2] * model.b1[s,f2,1,m] * model.x[s,f2,1,m]
    if i:
        return expr == model.aff[f1,f2]
    else:
        return expr == 0
model.PDisjunct = Disjunct(model.index_f1f2, [0,1], rule=P_constraint_rule)

def P_disjunction_rule(m,f1,f2):
    return [ m.PDisjunct[f1,f2,i] for i in [0,1] ]
model.PDisjunction = Disjunction(model.index_f1f2, rule=P_Disjunction_rule)

然后，您需要调用转换将析取转换回代数约束。注意：转换要么需要您的 Pyomo 变量都有下限和上限，要么您需要通过BigM模型上的后缀指定有效的“Big-M”值。您可以：

  • 在 Pyomo 命令行上指定转换（例如，--transform=gdp.bigm或--transform=gdp.chull）

  • 在 a 中指定转换BuildAction

    def xfrm(m):
    TransformationFactory('gdp.bigm').apply_to(m)
model.xfrm = BuildAction(rule=xfrm)

  • 显式调用转换作为自定义驱动程序脚本的一部分。

另一种方法pyomo.gdp是自己明确实施放松。您需要添加一个二进制变量（我们称它为y），指示析取的哪一侧必须为 True，然后使用该二进制变量显式放宽两个析取。从概念上讲，你会转

expr == model.aff[f1,f2] | expr == 0

进入

expr - model.aff[f1.f2] <= M1 * y
model.aff[f1.f2] - expr <= M2 * y
expr <= M3 * (1-y)
expr >- M4 * (1-y)

请注意，根据 和 的界限expr，aff其中一些约束可能是多余的。此外，四个“Big-M”（大常数）可能不一定需要不同，但如果您可以确定每个 M 的最小有效值，问题会更好地解决。

于 2017-05-18T15:10:24.563 回答
0

谢谢@jsiirola。

我用 Big-M-relaxation 实现了约束。有用。

此外，我简化了 expr- 和 return- 语句。

对于每个 f（前 f1,f2）， (model.b[s,f,1,m] * model.x[s,f,1,m]) 的 S 和 M 的总和应等于 0 或 model.af [f]（以前的 model.aff[f1,f2]）。

model.af[f] 也被用作绑定 M。

## Big-M Relaxation
def P1_constraint_rule (model, f):
    expr = 0
    for (s,m) in model.index_sm:
        expr += model.b[s,f,1,m] * model.x[s,f,1,m]

    return expr <= model.af[f] * model.xf[f]

model.P1Constraint = Constraint(model.F, rule=P1_constraint_rule)


def P2_constraint_rule (model, f):
    expr = 0
    for (s,m) in model.index_sm:
        expr += model.b[s,f,1,m] * model.x[s,f,1,m]

    return expr >= model.af[f] * model.xf[f] 

model.P2Constraint = Constraint(model.F, rule=P2_constraint_rule)


def P3_constraint_rule (model, f):
    expr = 0
    for (s,m) in model.index_sm:
        expr += model.b[s,f,1,m] * model.x[s,f,1,m]

    return expr - model.af[f] <= model.af[f]  * (1- model.xf[f])

model.P3Constraint = Constraint(model.F, rule=P3_constraint_rule)


def P4_constraint_rule (model, f):
    expr = 0
    for (s,m) in model.index_sm:
        expr += model.b[s,f,1,m] * model.x[s,f,1,m]

    return model.af[f] - expr <= model.af[f] * (1- model.xf[f])

model.P4Constraint = Constraint(model.F, rule=P4_constraint_rule)
于 2017-05-28T11:22:04.410 回答