Question

Hei all，

我正在尝试为表格

的非常简单的QP设置一个抽象模型

min（x-x0）^ 2

s.t。

A x = b

C x <= d

我想使用抽象模型，因为我需要通过更改参数来解决（主要是x0，但也可能是A，b，C，d）。我现在正在简单地设置模型实例中的参数。我不想使用外部数据文件，而是使用内部python变量。我在网上找到的所有例子都使用AMPL格式的数据文件。

这是我现在的代码

import pyomo.environ as pe

model = pe.AbstractModel()

# the sets
model.n = pe.Param(within=pe.NonNegativeIntegers)
model.m = pe.Param(initialize = 1)
model.ss = pe.RangeSet(1, model.n)
model.os = pe.RangeSet(1, model.m)

# the starting point and the constraint parameters
model.x_hat = pe.Param(model.ss)
model.A = pe.Param(model.os, model.ss)
model.b = pe.Param(model.os)
model.C = pe.Param(model.os, model.os)
model.d = pe.Param(model.ss, model.os)

# the decision variables
model.x_projected = pe.Var(model.ss)

# the cosntraints
# A x = b
def sum_of_elements_rule(model):
    value = model.A * model.x_projected
    return value == model.d
model.sumelem = pe.Constraint(model.os, rule=sum_of_elements_rule)

# C x <= d
def positivity_constraint(model):
    return model.C*model.x_projected <= model.d

model.bounds = pe.Constraint(model.ss, rule=positivity_constraint)

# the cost
def cost_rule(model):
    return sum((model.x_projected[i] - model.x[i])**2 for i in model.ss)
model.cost = pe.Objective(rule=cost_rule)

instance = model.create_instance()

不知何故，我被困住了。我现在如何设置参数？

非常感谢，Theo

Answer 1

我知道这是一篇过时的文章，但是对此的解决方法可能会对我有所帮助，所以这里是此问题的解决方法：

## TEST
data_init= {None: dict(
        n = {None : 3},
        d = {0:0, 1:1, 2:2},
        x_hat = {0:10, 1:-1, 2:-100},
        b = {None: 10}
        )}
# create instance
instance = model.create_instance(data_init)

这将以与您创建的方式等效的方式创建实例，但是以更正式的方式。

Answer 2

好吧，我似乎已经弄明白问题是什么。如果我想在创建实例后设置参数，我需要

mutable=True

标记。然后，我可以用

之类的东西设置参数

for i in range(model_dimension):
    getattr(instance, 'd')[i] = i

我在创建实例之前需要选择的模型维度（这对我的情况来说是好的）。可以使用不同的约束参数重用该实例。下面的代码应该适用于问题

min (x-x_hat)' * (x-x_hat)
s.t.
sum(x) = b
x[i] >= d[i]

以x_hat，b，d作为参数。

import pyomo.environ as pe
model = pe.AbstractModel()

# model dimension
model.n = pe.Param(default=2)

# state space set
model.ss = pe.RangeSet(0, model.n-1)

# equality
model.b = pe.Param(default=5, mutable=True)

# inequality
model.d = pe.Param(model.ss, default=0.0, mutable=True)

# decision var
model.x = pe.Var(model.ss)
model.x_hat = pe.Param(model.ss, default=0.0, mutable=True)

# the cost
def cost_rule(model):
    return sum((model.x[i] - model.x_hat[i])**2 for i in model.ss)
model.cost = pe.Objective(rule=cost_rule)

# CONSTRAINTS
# each x_i bigger than d_i
def lb_rule(model, i):
    return (model.x[i] >= model.d[i])
model.state_bound = pe.Constraint(model.ss, rule=lb_rule)

# sum of x == P_tot
def sum_rule(model):
    return (sum(model.x[i] for i in model.ss) == model.b)
model.state_sum = pe.Constraint(rule=sum_rule)

## TEST
# define model dimension
model_dimension = 3
model.n = model_dimension

# create instance
instance = model.create_instance()
# set d
for i in range(model_dimension):
    getattr(instance, 'd')[i] = i

# set x_hat
xh = (10,1,-100)
for i in range(model_dimension):
    getattr(instance, 'x_hat')[i] = xh[i]

# set b
instance.b = 10

# solve
solver = pe.SolverFactory('ipopt')
result = solver.solve(instance)

instance.display()

PYOMO：如何使用内部数据的抽象模型

2 个答案: