如何在Pyomoconstraints中建模逻辑或量词

Question

我正在使用PYOMO，我想在“p_constraint_rule”中实现一个逻辑OR，但是我做不到。在

我的模型有一些部分：

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)

。。。在

^{pr2}$

e.g. in my .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应该对有效型号索引 等式p2约束应适用于model.F的2个元素或型号索引 像这样：

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)

先谢谢你，拉拉

Answer 1

谢谢@jsiirola。在

我用大M松弛实现了约束。它起作用了。在

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

对于每个f（原f1，f2），（b型[S，f，1，M]*model.x[S，f，1，M]）的S和M上的和应等于0或模型.af[f] （前模型.aff[f1，f2]）。在

在模型.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)

Answer 2

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

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

对于具体的语法问题：

• |是二进制或。它比关系运算符绑定得更紧，因此不会执行您想要的操作。在
• ||不是有效的Python语法
• 从概念上讲，您需要的是逻辑或，这在Python中是用or实现的。这将是一个很好的语法支持-但是，它目前不支持Pyomo。在

您有两个选项来指定这样的约束：要么（1）使用pyomo.gdp扩展将其指定为析取，然后利用pyomo.gdp中的转换将析取程序松弛回MIP，或者（2）使用例如Big-M松弛显式地松弛析取。要执行前者，需要定义两个析取，然后定义析取：

^{pr2}$

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

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

• 在BuildAction中指定转换

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

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

替代pyomo.gdp的方法是自己显式地实现放松。您需要添加一个二进制变量（我们称之为y），它指示析取的哪一边必须为真，然后使用该二进制变量显式地放宽两个析取。从概念上讲你会转向

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的界限，其中一些约束可能是多余的。另外，四个“大M”（大常量）可能不一定要不同，尽管如果您能确定每个M的最小有效值，那么问题将得到更好的解决