Pyomo 入门：用 Python 实现数学优化建模

（1）ConcreteModel：数据先行，即时构建

适用于数据已知的场景，模型结构与数据同步定义，用 Python 原生数据结构（列表、字典）传入参数。

示例：简单线性规划

目标函数：\(\min\ x_1 + 2x_2\)

约束条件：

\(3x_1 + 4x_2 \geq 1\)

\(2x_1 + 5x_2 \geq 2\)

\(x_1, x_2 \geq 0\)

代码实现（修正文档中的语法错误后）：

import pyomo.environ as pyo

\# 1. 初始化ConcreteModel

model = pyo.ConcreteModel(name="SimpleLP")

\# 2. 定义变量（Var）：非负实数

model.x1 = pyo.Var(within=pyo.NonNegativeReals)

model.x2 = pyo.Var(within=pyo.NonNegativeReals)

\# 3. 定义目标函数（Objective）：最小化

model.obj = pyo.Objective(expr=model.x1 + 2 \* model.x2, sense=pyo.minimize)

\# 4. 定义约束（Constraint）

model.con1 = pyo.Constraint(expr=3 \* model.x1 + 4 \* model.x2 >= 1)

model.con2 = pyo.Constraint(expr=2 \* model.x1 + 5 \* model.x2 >= 2)

\# 5. 求解（调用GLPK求解器）

solver = pyo.SolverFactory("glpk")

result = solver.solve(model)

\# 6. 验证结果与输出

pyo.assert\_optimal\_termination(result)  # 确保求解成功

print("最优解：")

print(f"x1 = {pyo.value(model.x1)}")

print(f"x2 = {pyo.value(model.x2)}")

print(f"目标函数值 = {pyo.value(model.obj)}")

（2）AbstractModel：先定结构，后传数据

适用于数据未知或需多次替换数据的场景（如批量求解不同参数的问题）。模型结构先通过 Set（集合）和 Param（参数）抽象定义，数据后续传入（Bynum et al., 2021）。

示例：参数化线性规划

目标函数：\(\min\ \sum_{i \in N} c_i x_i\)

约束条件：\(\sum_{i \in N} a_{ji} x_i \geq b_j\ (\forall j \in M)\)，\(x_i \geq 0\)

代码实现：

import pyomo.environ as pyo

\# 1. 初始化AbstractModel（仅定义结构，无数据）

model = pyo.AbstractModel(name="ParametricLP")

\# 2. 定义集合（Set）：索引容器

model.N = pyo.Set()  # 变量索引集合（如i=1,2）

model.M = pyo.Set()  # 约束索引集合（如j=1,2）

\# 3. 定义参数（Param）：模型的输入数据

model.c = pyo.Param(model.N)  # 目标函数系数（对应c\_i）

model.a = pyo.Param(model.M, model.N)  # 约束系数（对应a\_ji）

model.b = pyo.Param(model.M)  # 约束右侧值（对应b\_j）

\# 4. 定义变量与目标函数（依赖Set/Param，无需具体数据）

model.x = pyo.Var(model.N, within=pyo.NonNegativeReals)

def obj\_rule(mdl):

    return sum(mdl.c\[i] \* mdl.x\[i] for i in mdl.N)  # 列表推导式（Pyomo推荐写法）

model.obj = pyo.Objective(rule=obj\_rule, sense=pyo.minimize)

\# 5. 定义约束（用rule函数复用逻辑）

def con\_rule(mdl, j):  # j为约束索引，来自Set M

    return sum(mdl.a\[j, i] \* mdl.x\[i] for i in mdl.N) >= mdl.b\[j]

model.con = pyo.Constraint(model.M, rule=con\_rule)

\# 6. 传入数据并求解（示例数据）

data = {

    "N": {None: \[1, 2]},  # None表示Set无父索引

    "M": {None: \[1, 2]},

    "c": {None: {1: 1, 2: 2}},

    "a": {None: {(1,1): 3, (1,2): 4, (2,1): 2, (2,2): 5}},

    "b": {None: {1: 1, 2: 2}}

}

instance = model.create\_instance(data)  # 绑定数据生成实例

\# 7. 求解与输出

solver = pyo.SolverFactory("glpk")

result = solver.solve(instance)

pyo.assert\_optimal\_termination(result)

instance.x.pprint()  # 打印所有变量的最优解

步骤 1：Excel 数据格式（示例）

步骤 2：Pyomo 代码

import pyomo.environ as pyo

import pandas as pd

\# 1. 从Excel读取数据

df = pd.read\_excel("wl\_data.xlsx", sheet\_name="Delivery Costs", header=0, index\_col=0)

N = list(df.index.map(str))  # 候选仓库集合

M = list(df.columns.map(str))  # 客户集合

d = {(r, c): df.at\[r, c] for r in N for c in M}  # 运输成本字典

P = 2  # 仓库数量限制

\# 2. 定义ConcreteModel

def create\_warehouse\_model(N, M, d, P):

    model = pyo.ConcreteModel(name="WarehouseLocation")

    

    \# 变量：x\[n,m]（服务比例）、y\[n]（是否选仓库）

    model.x = pyo.Var(N, M, bounds=(0, 1))

    model.y = pyo.Var(N, within=pyo.Binary)

    

    \# 目标函数：最小化总运输成本

    def obj\_rule(mdl):

        return sum(d\[n, m] \* mdl.x\[n, m] for n in N for m in M)

    model.obj = pyo.Objective(rule=obj\_rule, sense=pyo.minimize)

    

    \# 约束1：每个客户需求全满足

    def demand\_rule(mdl, m):

        return sum(mdl.x\[n, m] for n in N) == 1

    model.demand = pyo.Constraint(M, rule=demand\_rule)

    

    \# 约束2：未选仓库不服务

    def warehouse\_active\_rule(mdl, n, m):

        return mdl.x\[n, m] <= mdl.y\[n]

    model.warehouse\_active = pyo.Constraint(N, M, rule=warehouse\_active\_rule)

    

    \# 约束3：仓库数量限制（用mutable Param支持动态修改）

    model.P = pyo.Param(initialize=P, mutable=True)

    def num\_warehouses\_rule(mdl):

        return sum(mdl.y\[n] for n in N) <= mdl.P

    model.num\_warehouses = pyo.Constraint(rule=num\_warehouses\_rule)

    

    return model

\# 3. 求解与结果输出

model = create\_warehouse\_model(N, M, d, P)

solver = pyo.SolverFactory("glpk")

result = solver.solve(model)

\# 验证最优解并打印仓库选择结果

pyo.assert\_optimal\_termination(result)

print("最优仓库选择（y\[n]=1表示选中）：")

model.y.pprint()

print(f"最小总运输成本：{pyo.value(model.obj)}")