Pyomo技术问询：如何用内部数据为抽象模型设置参数

嘿，我来帮你搞定这个Pyomo抽象模型参数设置的问题！你不想依赖外部AMPL数据文件完全合理，Pyomo本身就支持直接用Python原生变量、字典给抽象模型的实例赋值，不用走外部文件的路子。

先提一下你原代码里几个需要修正的小问题，避免后续踩坑：

• 目标函数里的model.x[i]应该是model.x_hat[i]（你定义的参数是x_hat）
• 约束里的model.A * model.x_projected写法不对，Pyomo中矩阵乘法需要用求和实现，应该写成sum(model.A[o, s] * model.x_projected[s] for s in model.ss)
• 参数维度与原问题不匹配：原问题的Cx ≤ d中，C是约束数×变量数的矩阵，d是约束数长度的向量，你原代码里model.C设为(model.os, model.os)、model.d设为(model.ss, model.os)不符合问题定义，我后续会调整过来。

接下来给你两种常用的参数设置方法：

方法1：创建实例时直接传入数据字典 #

你可以在create_instance()方法中直接传入包含所有参数数据的字典，键为参数名，值对应参数的结构（带索引的参数用嵌套字典或索引-值对字典）。

比如假设我们的问题参数如下：

• 变量数n=3，等式约束数m_eq=1，不等式约束数m_ineq=3
• 目标点x_hat = [1.0, 2.0, 3.0]
• 等式约束矩阵A = [[1, 1, 1]]，右端项b = [6.0]
• 不等式约束矩阵C为单位矩阵（对应每个变量x_i ≤5），右端项d = [5.0, 5.0, 5.0]

对应的代码写法：

# 定义参数数据字典
data = {
    None: {  # None对应无索引的全局参数
        'n': {None: 3},
        'm_eq': {None: 1},
        'm_ineq': {None: 3},
    },
    'x_hat': {  # 单索引参数：键为索引，值为参数值
        1: 1.0,
        2: 2.0,
        3: 3.0,
    },
    'A': {  # 双索引参数：键为(行索引, 列索引)元组
        (1, 1): 1.0,
        (1, 2): 1.0,
        (1, 3): 1.0,
    },
    'b': {
        1: 6.0,
    },
    'C': {
        (1, 1): 1.0,
        (2, 2): 1.0,
        (3, 3): 1.0,
    },
    'd': {
        1: 5.0,
        2: 5.0,
        3: 5.0,
    },
}

# 创建实例时传入数据
instance = model.create_instance(data)

方法2：实例创建后逐个/批量赋值 #

如果参数需要动态生成，或者你想分步设置，可以先创建空实例，再通过instance.参数名来赋值：

# 先创建空实例，需先指定全局参数的值
instance = model.create_instance({None: {'n':3, 'm_eq':1, 'm_ineq':3}})

# 批量给x_hat赋值
instance.x_hat.update({1:1.0, 2:2.0, 3:3.0})

# 批量给A赋值
instance.A.update({(1,1):1.0, (1,2):1.0, (1,3):1.0})

# 单个参数赋值
instance.b[1] = 6.0

# 给不等式约束参数赋值
instance.C.update({(1,1):1.0, (2,2):1.0, (3,3):1.0})
instance.d.update({1:5.0, 2:5.0, 3:5.0})

完整的修正后代码 #

把以上内容整合，加上正确的约束、目标函数和求解逻辑的完整代码如下：

import pyomo.environ as pe

# 定义抽象模型
model = pe.AbstractModel()

# 集合与全局参数
model.n = pe.Param(within=pe.NonNegativeIntegers)  # 变量数
model.m_eq = pe.Param(within=pe.NonNegativeIntegers)  # 等式约束数
model.m_ineq = pe.Param(within=pe.NonNegativeIntegers)  # 不等式约束数
model.ss = pe.RangeSet(1, model.n)  # 变量索引集合
model.os_eq = pe.RangeSet(1, model.m_eq)  # 等式约束索引集合
model.os_ineq = pe.RangeSet(1, model.m_ineq)  # 不等式约束索引集合

# 参数定义（修正维度匹配问题）
model.x_hat = pe.Param(model.ss)  # 目标点x0
model.A = pe.Param(model.os_eq, model.ss)  # 等式约束矩阵A (m_eq × n)
model.b = pe.Param(model.os_eq)  # 等式约束右端项b (m_eq × 1)
model.C = pe.Param(model.os_ineq, model.ss)  # 不等式约束矩阵C (m_ineq × n)
model.d = pe.Param(model.os_ineq)  # 不等式约束右端项d (m_ineq × 1)

# 决策变量
model.x_projected = pe.Var(model.ss, domain=pe.Reals)

# 等式约束：Ax = b
def eq_constraint_rule(model, o):
    return sum(model.A[o, s] * model.x_projected[s] for s in model.ss) == model.b[o]
model.eq_constraints = pe.Constraint(model.os_eq, rule=eq_constraint_rule)

# 不等式约束：Cx ≤ d
def ineq_constraint_rule(model, o):
    return sum(model.C[o, s] * model.x_projected[s] for s in model.ss) <= model.d[o]
model.ineq_constraints = pe.Constraint(model.os_ineq, rule=ineq_constraint_rule)

# 目标函数：min (x - x_hat)^2
def cost_rule(model):
    return sum((model.x_projected[s] - model.x_hat[s])**2 for s in model.ss)
model.cost = pe.Objective(rule=cost_rule, sense=pe.minimize)

# 设置参数并创建实例（采用方法1）
data = {
    None: {
        'n': {None: 3},
        'm_eq': {None: 1},
        'm_ineq': {None: 3},
    },
    'x_hat': {1:1.0, 2:2.0, 3:3.0},
    'A': {(1,1):1.0, (1,2):1.0, (1,3):1.0},
    'b': {1:6.0},
    'C': {(1,1):1.0, (2,2):1.0, (3,3):1.0},
    'd': {1:5.0, 2:5.0, 3:5.0},
}
instance = model.create_instance(data)

# 调用求解器（需提前安装ipopt等求解器）
solver = pe.SolverFactory('ipopt')
result = solver.solve(instance)

# 打印求解结果
print("求解状态：", result.solver.status)
print("最优目标值：", instance.cost())
print("最优解：")
for s in instance.ss:
    print(f"x_projected[{s}] = {instance.x_projected[s].value}")

这样你就可以随时修改data字典里的x_hat、A、b等参数，重新创建实例求解，完全不需要依赖外部文件。

内容的提问来源于stack exchange，提问作者Theo