使用Pyomo进行优化：完整的分步指南>

设置Pyomo

在我们深入建模之前，我们需要通过安装Pyomo并选择一个合适的求解器来设置我们的环境。

1. 先决条件

要使用Pyomo，您必须有Python 3.6或更高版本。Pyomo可以通过pip安装。

pip install pyomo

本教程是在 pyomo 版本 6.8.0 下创建的。

import pyomo
print(pyomo.__version__)

输出：

>>> 6.8.0

2. 选择并安装正确的求解器

在优化中，求解器是至关重要的，因为它们是找到你定义问题最优解的算法。不同的求解器根据问题类型（例如，线性、非线性、整数）而有不同的适用场景。Pyomo 是一个建模工具，它依赖于外部求解器来进行实际的计算。

让我们回顾一些最常用的求解器。

开源求解器

1. GLPK（GNU 线性规划套件）

GLPK是一个解决线性规划（LP）和混合整数规划（MIP）问题受欢迎的工具。

它对于基本的线性优化任务是一个卓越的选择，并在学术界和工业应用中被广泛使用。

安装

• Windows: 下载并安装GLPK。
• macOS: 

brew install glpk

• Linux: 

sudo apt-get install glpk-utils

2. CBC（Coin-or Branch and Cut）

CBC是一个开源的线性规划（LP）和混合整数规划（MIP）问题的求解器。

它提供了高级功能和更好的性能，在某些情况下，与GLPK相比，使其成为更复杂优化任务的一个强有力选择。

CBC可以通过conda包管理器进行安装。

conda install -c conda-forge coincbc

3. IPOPT（内点优化器）

IPOPT是一个强大的求解器，专为大规模非线性规划（NLP）问题而设计。

它特别适合处理复杂非线性模型，使其成为解决线性优化之外问题的优秀选择。

IPOPT可以通过conda包管理器进行安装。

!conda install -c conda-forge ipopt

商业求解器

1. CPLEX

CPLEX 是一种先进的优化求解器，能够高效地处理线性规划（LP）、混合整数规划（MIP）和二次规划（QP）问题。

它需要从IBM获得许可证，但对学术用户免费，使其成为研究和教育目的的优秀选择。

2. Gurobi

Gurobi是一个知名的商业求解器，以其在解决线性规划（LP）、混合整数规划（MIP）、二次规划（QP）和非线性规划（NLP）问题中的速度和效率而闻名。

与CPLEX类似，它需要许可证，但为学术用户提供了免费访问。因此，它是先进优化的行业标准工具。

开源求解器与商业求解器对比

像GLPK和CBC这样的开源求解器是免费的，足以满足大多数基本优化需求。它们是小规模项目和教育用途的优秀选择。

然而，像CPLEX和Gurobi这样的商业求解器通常提供更优越的性能，尤其是在处理更大、更复杂的问题时。这些求解器具有先进的功能，包括增强的二次和非线性编程支持，并针对大规模工业应用进行了优化。

虽然开源求解器可以处理许多常规优化任务，但在面对更复杂、高性能要求时，商业求解器通常是更好的选择。

请记住，商业求解器需要许可证，尽管它们对学术用户是免费的。

现在，我们来看看如何在Pyomo中配置一个求解器。在这个例子中，我将使用GLPK。

3. 在Pyomo中配置求解器

首先，确保在安装后，求解器的可执行文件在您的系统PATH中。

然后，创建一个Python脚本，并添加以下内容：

from pyomo.environ import SolverFactory
solver = SolverFactory('glpk')

为了确认Pyomo和您的求解器都已正确安装，让我们解决一个简单的测试问题。

测试问题：简单的线性规划问题

目标：最小化Z=x+y

约束条件：

• x + 2y ≥ 4
• x – y ≤ 1
• x ≥ 0
• y ≥ 0

这个问题是关于找到Z的最小可能值，它是由两个变量x和y的和组成的。然而，x和y必须满足某些条件。

首先，当你加上x和两倍的y时，结果至少必须是4。其次，x减去y必须小于或等于1。最后， bothx和y必须是零或正数（它们不能是负数）。

目标是找到满足这些条件的x和y的值，同时使Z尽可能小。

使用Pyomo实现：

import pyomo.environ as pyo
# 创建一个模型
model = pyo.ConcreteModel()
# 定义变量
model.x = pyo.Var(within=pyo.NonNegativeReals)
model.y = pyo.Var(within=pyo.NonNegativeReals)
# 定义目标函数
model.obj = pyo.Objective(expr=model.x + model.y, sense=pyo.minimize)
# 定义约束条件
model.con1 = pyo.Constraint(expr=model.x + 2 * model.y >= 4)
model.con2 = pyo.Constraint(expr=model.x - model.y <= 1)
# 选择求解器
solver = pyo.SolverFactory('glpk')
# 求解问题
result = solver.solve(model)
# 显示结果
print('Status:', result.solver.status)
print('Termination Condition:', result.solver.termination_condition)
print('Optimal x:', pyo.value(model.x))
print('Optimal y:', pyo.value(model.y))
print('Optimal Objective:', pyo.value(model.obj))

如果一切正常工作，预期的输出将是：

Status: ok
Termination Condition: optimal
Optimal x: 0.0
Optimal y: 2.0
Optimal Objective: 2.0

让我们来分析上面的代码：首先，它定义了两个变量 x 和 y，它们的值不能是负数。模型的目标是最小化 x 和 y 的和（x + y）。代码定义了一个求解器 glpk，以找到 x 和 y 的最优值，这些值满足这些约束的同时最小化了目标函数。

在运行代码后，我们发现变量的最优值是 x = 0.0 和 y = 2.0 ，这使得目标函数 Z = x + y 最小化。因此，目标函数的最小值是 2.0 ，这满足了给定的约束条件。

Pyomo建模基础

了解如何在Pyomo中定义优化模型的基本组成部分，这对于有效地设置和解决优化问题至关重要。

1. 定义变量

变量代表优化问题中需要做出的决策。在Pyomo中，变量是求解器将调整以优化目标函数同时满足所有约束的数量。

标量变量

标量变量是没有在集合上索引的单个变量。在Pyomo中定义标量变量，您使用来自pyomo.environ模块的Var类。

from pyomo.environ import Var
model.x = Var()

我们首先导入Var，并使用Var()创建一个名为x的变量。这个变量没有指定的界限，意味着它可以取任何实数值，除非在模型中另有约束。

添加界限

您可以通过指定界限来限制变量可以采取的值。界限被定义为一个元组（lower_bound，upper_bound）：

from pyomo.environ import Var
model.x = Var(bounds=(0, None))

指定领域

Pyomo 提供预定义的领域，您可以使用它们来指定变量可以采取的值的类型，例如 NonNegativeReals、Integers 或 Binary：

from pyomo.environ import Var, NonNegativeReals
model.x = Var(domain=NonNegativeReals)

索引变量

当处理多个性质相似的变量时，例如代表不同时间段或项目的变量，使用索引变量是高效的。索引变量是定义在集合上的变量。

import pyomo.environ as pyo
model.I = pyo.Set(initialize=[1, 2, 3])
model.y = pyo.Var(model.I, domain=pyo.NonNegativeReals)

假设您正在为三种产品建模生产量。您可以定义：

model.Products = pyo.Set(initialize=['A', 'B', 'C'])
model.production = pyo.Var(model.Products, domain=pyo.NonNegativeReals)

现在，model.production['A']、model.production['B'] 和 model.production['C'] 分别代表产品A、B和C的生产数量。

2. 定义目标

目标函数是我们试图优化的函数（最小化或最大化）。它定义了模型的目标，比如最小化成本或最大化利润，通常表示为涉及决策变量的数学方程。

这使用Objective类来定义：

from pyomo.environ import ConcreteModel, Var, Objective, minimize, maximize, NonNegativeReals
# 创建模型
model = ConcreteModel()
# 定义变量
model.x = Var(within=NonNegativeReals)
model.y = Var(within=NonNegativeReals)
# 最小化（成本）
model.cost = Objective(expr=2 * model.x + 3 * model.y, sense=minimize)
# 最大化利润 - （一次只能有一个目标）
# model.profit = Objective(expr=5 * model.x + 4 * model.y, sense=maximize)

3. 添加约束

约束定义了问题的限制或要求：

from pyomo.environ import Constraint
model.con1 = Constraint(expr=model.x + model.y >= 10)

上述示例使用Pyomo模型中的Constraint类定义了一个约束。约束model.con1指定变量x和y的和必须大于或等于10。

4. 参数化模型

参数是在模型中使用的固定值，用于表示在优化过程中不会改变的已知量或常数。

它们有助于定义变量之间的关系和约束，通过引入现实世界的数据或假设，为模型提供结构：

from pyomo.environ import Param
model.p = Param(initialize=5)

上面的代码使用Pyomo模型中的Param类定义了一个参数p，并将其初始化为一个固定值
5
。现在，参数p可以在模型中使用，以表示在优化过程中不会改变的常数值。

现在，让我们来解决一个端到端的优化问题！

Pyomo 端到端示例

让我们通过 Pyomo 来解决一个优化问题的端到端示例。我们将构建一个真实世界的场景，其中一家工厂生产两种产品，目标是最大化利润，同时考虑机器时间约束。

1. 问题陈述

一家工厂生产两种产品，P1 和 P2。每单位利润为：

• P1: $40
• 自定义分隔符P2: $50

机器可用时间：

• 机器A: 100小时
• 机器B: 80小时
• 机器C: 90小时

每单位所需时间：

目标：最大化利润。

决策变量：

• x₁：生产P1的单位数。
• x₂: 生产的 P2 单位。

2. 数学公式

目标函数:

最大化 Z = 40x₁ + 50x₂

约束条件:

1. 机器 A 的容量: 1x₁ + 2x₂ ≤ 100
2. 机器B的产能：2x₁ + 1x₂ ≤ 80
3. 机器C的产能：3x₂ ≤ 90
4. 非负性：x₁, x₂ ≥ 0

3. 实施

根据问题的目标和约束，以下是使用GLPK的Python代码来建模它，再次说明。

第1步：导入库
import pyomo.environ as pyo
第2步：创建一个具体模型
model = pyo.ConcreteModel()
第3步：定义决策变量（生产P1和P2的单位）
model.x1 = pyo.Var(within=pyo.NonNegativeReals)
model.x2 = pyo.Var(within=pyo.NonNegativeReals)
第4步：定义目标函数（最大化利润）
model.profit = pyo.Objective(expr=40 * model.x1 + 50 * model.x2, sense=pyo.maximize)
第5步：定义约束条件
机器A的产能约束：1x1 + 2x2 <= 100
model.machine_a = pyo.Constraint(expr=1 * model.x1 + 2 * model.x2 <= 100)
机器B的产能约束：2x1 + 1x2 <= 80
model.machine_b = pyo.Constraint(expr=2 * model.x1 + 1 * model.x2 <= 80)
机器C的产能约束：3x2 <= 90
model.machine_c = pyo.Constraint(expr=3 * model.x2 <= 90)
第6步：使用GLPK求解器解决模型
solver = pyo.SolverFactory('glpk')
result = solver.solve(model)
第7步：分析结果
输出求解器状态和终止条件
print('Solver Status:', result.solver.status)
print('Termination Condition:', result.solver.termination_condition)
获取并显示x1、x2的最优值以及最大利润
x1_opt = pyo.value(model.x1)
x2_opt = pyo.value(model.x2)
profit_opt = pyo.value(model.profit)
print(f'Optimal production of P1 (x1): {x1_opt}')
print(f'Optimal production of P2 (x2): {x2_opt}')
print(f'Maximum Profit: ${profit_opt}')

输出：

>>> Solver Status: ok
>>> Termination Condition: optimal
>>> Optimal production of P1 (x1): 25.0
>>> Optimal production of P2 (x2): 30.0
>>> Maximum Profit: $2500.0

在上述代码中，我们定义了一个线性优化模型，以最大化生产两种产品（P1和P2）的利润。目标函数被设置为最大化利润，每单位P1贡献40美元，每单位P2贡献50美元。

我们施加三个约束条件，代表机器A、B和C的机器时间限制。

最后，我们使用GLPK求解器来解决问题。

最终的答案是生产25单位P1和30单位P2，这样我们的最大利润将是2500美元。

在Pyomo中的高级功能

在前一部分，我们看到了使用Pyomo实现端到端优化问题是多么简单。然而，大多数现实生活中的问题并不容易解决。

在本节中，我将介绍一些高级功能，你可以用来解决更复杂的场景。

1. 非线性优化

非线性优化旨在最小化或最大化非线性目标函数，同时满足非线性约束。让我们看一个例子，我们最小化平方差之和，同时受到圆形约束。

问题陈述

目标最小化：Z = (x – 1)² + (y – 2)²

约束条件：

• x² + y² ≤ 4
• x, y ≥ 0

在Pyomo中，我们可以定义决策变量xy，并设置其范围为0，以确保非负性。目标函数表示为特定点的平方差之和，约束条件确保解决方案在半径为2.的圆内。

在这种情况下，IPOPT求解器因其非线性优化问题求解能力而适用：

import pyomo.environ as pyo
model = pyo.ConcreteModel()
# 定义具有下界的变量
model.x = pyo.Var(bounds=(0, None))
model.y = pyo.Var(bounds=(0, None))
# 目标函数：最小化 (x - 1)² + (y - 2)²
model.obj = pyo.Objective(expr=(model.x - 1)**2 + (model.y - 2)**2, sense=pyo.minimize)
# 约束条件：x² + y² ≤ 4 （半径为2的圆）
model.circle = pyo.Constraint(expr=model.x**2 + model.y**2 <= 4)
solver = pyo.SolverFactory('ipopt')
result = solver.solve(model)
print('Optimal x:', pyo.value(model.x))
print('Optimal y:', pyo.value(model.y))
print('Minimum Z:', pyo.value(model.obj))

2. 混合整数规划（MIP）

当一些决策变量是整数（通常是二进制）而其他变量是连续的时，使用混合整数规划。它在设施定位和生产计划等决策问题中非常有价值。

问题陈述

一家公司必须决定是否在地点A、B和C开设仓库。目标是尽量降低总成本，这包括开设仓库的固定成本和运输成本。

我们首先初始化数据，包括开设仓库的固定成本、运输成本、容量限制和总需求：

locations = ['A', 'B', 'C']
FixedCost = {'A': 1000, 'B': 1200, 'C': 1500}
TransportCost = {'A': 5, 'B': 4, 'C': 6}
Capacity = {'A': 100, 'B': 80, 'C': 90}
Demand = 150
model = pyo.ConcreteModel()
# 二进制变量：如果仓库开放则为1，否则为0
model.y = pyo.Var(locations, domain=pyo.Binary)
# 连续变量：运输的货物量
model.x = pyo.Var(locations, domain=pyo.NonNegativeReals)
model.cost = pyo.Objective(
    expr=sum(FixedCost[i] * model.y[i] + TransportCost[i] * model.x[i] for i in locations),
    sense=pyo.minimize
)
# 需求约束
model.demand = pyo.Constraint(expr=sum(model.x[i] for i in locations) >= Demand)
# 容量约束
def capacity_rule(model, i):
    return model.x[i] <= Capacity[i] * model.y[i]
model.capacity = pyo.Constraint(locations, rule=capacity_rule)
solver = pyo.SolverFactory('cbc')
result = solver.solve(model)
for i in locations:
    print(f"Warehouse {i}: Open={pyo.value(model.y[i])}, Transported={pyo.value(model.x[i])}")
print('Minimum Total Cost:', pyo.value(model.cost))

模型包括两种类型的决策变量：一个二进制变量y，表示仓库是否开放（如果开放则为1，否则为0），和一个连续变量x，表示从每个仓库运输的货物量。

目标函数计算每个仓库的固定成本和运输成本，并最小化总成本。约束条件确保运输的货物总量满足需求，同时如果开启仓库，则不会超过每个仓库的容量。

3. 处理多个目标

有时，优化问题涉及多个可能冲突的目标，例如在最小化环境影响的同時最大化利润。常见的方法是加权求和法，为每个目标分配一个权重，以平衡其重要性。

问题陈述

我们旨在最大化利润同时最小化环境影响：

• 利润：Z₁ = 3x + 5y
• 环境影响：Z₂ = 2x + y

我们可以使用权重 w1=0.6, w2=0.4 结合这些目标，其中总目标变为加权之和：

w1 = 0.6
w2 = 0.4
model.obj = pyo.Objective(
    expr=w1 * (3 * model.x + 5 * model.y) - w2 * (2 * model.x + model.y),
    sense=pyo.maximize
)

在组合目标中，通过调整权重，我们可以在最大化利润的同时最小化环境影响。

4. 使用外部数据源

在处理大数据集时，导入来自外部源（如CSV文件）的数据通常很有用。Pyomo与Pandas配合良好，可用于读取和使用外部数据。

我们可以使用Pandas读取CSV文件，并使用数据初始化模型中的集合和参数：

import pandas as pd
data = pd.read_csv('parameters.csv')
# 从CSV数据定义集合
model.I = pyo.Set(initialize=data['index'].unique())
# 从CSV数据定义初始化的参数
param_dict = data.set_index('index')['value'].to_dict()
model.param = pyo.Param(model.I, initialize=param_dict)

使用Pyomo的技巧和最佳实践

在使用Pyomo时，保持模型的效率、文档齐全且易于故障排除是很重要的。

1. 调试和故障排除

在Pyomo中构建优化模型时，经常会遇到诸如不可行解、求解器失败或结果不正确等问题。以下是一些调试的最佳实践：

• 检查约束条件：如果你的模型没有产生一个可行的解决方案，请检查你的约束条件。过紧的约束条件会使问题变得不可行。使用Pyomo的.display()方法打印出变量和约束的值，以验证它们是否如预期般运行。
• 求解器输出：通过在调用solve()方法时传递tee=True来启用详细的求解器日志。这可以提供求解器可能遇到问题的线索，例如 unbounded变量或不可行性。
• 首先测试简单模型：在处理复杂模型时，先测试简化版本。这有助于隔离潜在问题，而无需完全指定模型的开销。

如果您系统地 approach troubleshooting, 分析约束、目标函数和求解器反馈，那么故障排除会容易得多。

2. 建模效率

随着模型大小的增加，优化问题可能会变得计算成本高昂。为确保建模效率，请考虑以下建议：

• 利用稀疏性：在定义约束或目标时，避免对不必要的索引进行循环。利用问题的稀疏性可以减少计算时间。
• 二进制变量与连续变量：在可能的情况下，减少二进制或整数变量的数量。连续变量更容易被求解器处理，从而导致更快的结果。
• 约束制定：尽可能保持约束的简单性，无论是在数学形式上还是在实现上。避免不必要的非线性，并将复杂的约束分解为更小、更容易管理的约束。

高效的模型解决速度更快，且更容易调试和维护。

3. 文档和维护

维护好文档的Pyomo模型是一种长期使用和协作的好习惯。良好的文档也能使随着时间的推移更容易回顾和更新模型：

• 使用内联注释： 始终为变量、约束和目标函数添加注释以解释其目的。这在优化模型中尤为重要，因为其中的逻辑可能不会立即显而易见。
• 模块化你的代码：将你的模型分解为逻辑部分，甚至可以分离成单独的函数。这种模块化方法可以提高代码的可读性，并使模型中特定部分的调试和修改变得更加容易。
• 追踪模型更改：特别是如果你的模型在不断演变，保持模型版本的历史记录。使用版本控制工具如Git来追踪更改，确保任何更新或改进都能被追溯回去。

适当的文档和结构化代码将使你的Pyomo模型对未来协作者更加开放，并且随着需求的演变，更容易扩展或修改。

结论

Pyomo是一个强大且灵活的工具，可用于在Python中构建和解决优化模型。在本教程中，我们探讨了Pyomo如何允许用户建模各种优化问题，从线性规划到非线性和混合整数规划。

凭借其用户友好的语法和对求解器的集成，Pyomo使制定和解决现实世界的优化问题既适合初学者也适合高级用户。

如果您有兴趣了解更多关于使用优化解决现实世界问题的知识，请查看DataCamp上的Python优化入门免费课程！