使用Pymoo库实现多目标优化算法优化自定义问题

最新推荐文章于 2025-03-13 14:25:18 发布
最新推荐文章于 2025-03-13 14:25:18 发布
阅读量1.7k 收藏 24
点赞数 19
文章标签： 算法 python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Caidaji/article/details/144403627
版权

一、本文的目的：

1、通过Pymoo库实现多目标优化算法，用于优化自定义问题，例如调度问题

二、重要库文件版本：

python 3.6

pymoo 0.6.1.2 

三、通过Pymoo实现多目标优化

3.0过程步骤：

  1. 定义问题
    • 是否启用并行计算
  2. 初始化算法
    • 设置各种算子
  3. 设置终止条件
  4. 组装部件，执行优化

3.1定义问题

定义问题包含变量数量、变量范围、约束数量、适应值计算函数等，下面是定义问题的相关参数。

import numpy as np
from pymoo.core.problem import ElementwiseProblem

class MyProblem(ElementwiseProblem):

    def __init__(self, **kwargs):
        super().__init__(n_var=2,
                         n_obj=2,
                         n_ieq_constr=2,
                         xl=np.array([-2,-2]),
                         xu=np.array([2,2]),
                         **kwargs)  # 在问题定义时可以设置并行计算的参数  
        # https://pymoo.org/problems/parallelization.html

    def _evaluate(self, x, out, *args, **kwargs):
        f1 = 100 * (x[0]**2 + x[1]**2)
        f2 = (x[0]-1)**2 + x[1]**2

        g1 = 2*(x[0]-0.1) * (x[0]-0.9) / 0.18
        g2 = - 20*(x[0]-0.4) * (x[0]-0.6) / 4.8

        out["F"] = [f1, f2]
        out["G"] = [g1, g2]

problem = MyProblem()

3.2初始化算法（设置算子相关参数）

 选择NSGA-II 多目标优化算法，设置各种算子，各种算子操作符open in new window，主要包括采样、选择、变异与交叉。

import numpy as np
from pymoo.core.problem import ElementwiseProblem

class MyProblem(ElementwiseProblem):

    def __init__(self, **kwargs):
        super().__init__(n_var=2,
                         n_obj=2,
                         n_ieq_constr=2,
                         xl=np.array([-2,-2]),
                         xu=np.array([2,2]),
                         **kwargs)  # 在问题定义时可以设置并行计算的参数  
        # https://pymoo.org/problems/parallelization.html

    def _evaluate(self, x, out, *args, **kwargs):
        f1 = 100 * (x[0]**2 + x[1]**2)
        f2 = (x[0]-1)**2 + x[1]**2

        g1 = 2*(x[0]-0.1) * (x[0]-0.9) / 0.18
        g2 = - 20*(x[0]-0.4) * (x[0]-0.6) / 4.8

        out["F"] = [f1, f2]
        out["G"] = [g1, g2]

problem = MyProblem()

3.3设置终止条件（例如，终止迭代次数）

通过设置代数为终止条件：

from pymoo.termination import get_termination
termination = get_termination("n_gen", 40)

3.4组装部件，执行优化

主要是组装前面的三种组件，执行优化：

from pymoo.optimize import minimize

res = minimize(problem,
               algorithm,
               termination,
               seed=1,  # seed 相同就能保证在任何地方执行的结果相同
               save_history=True, # 保存历史
               verbose=True)  # 输出优化过程  

X = res.X  # 结果中的自变量
F = res.F  # 结果中的目标量

3.5可视化

自变量的分布：

import matplotlib.pyplot as plt
xl, xu = problem.bounds()
plt.figure(figsize=(7, 5))
plt.scatter(X[:, 0], X[:, 1], s=30, facecolors='none', edgecolors='r')
plt.xlim(xl[0], xu[0])
plt.ylim(xl[1], xu[1])
plt.title("Design Space")
plt.show()

帕累托前沿：

plt.figure(figsize=(7, 5))
plt.scatter(F[:, 0], F[:, 1], s=30, facecolors='none', edgecolors='blue')
plt.title("Objective Space")
plt.show()

3.6完整可执行代码

import numpy as np
from pymoo.core.problem import ElementwiseProblem
from pymoo.algorithms.moo.nsga2 import NSGA2
from pymoo.operators.crossover.sbx import SBX
from pymoo.operators.mutation.pm import PM
from pymoo.operators.sampling.rnd import FloatRandomSampling
from pymoo.termination import get_termination
from pymoo.optimize import minimize
import matplotlib.pyplot as plt

class MyProblem(ElementwiseProblem):

    def __init__(self, **kwargs):
        super().__init__(n_var=2,
                         n_obj=2,
                         n_ieq_constr=2,
                         xl=np.array([-2,-2]),
                         xu=np.array([2,2]),
                         **kwargs)  # 在问题定义时可以设置并行计算的参数
        # https://pymoo.org/problems/parallelization.html

    def _evaluate(self, x, out, *args, **kwargs):
        f1 = 100 * (x[0]**2 + x[1]**2)
        f2 = (x[0]-1)**2 + x[1]**2

        g1 = 2*(x[0]-0.1) * (x[0]-0.9) / 0.18
        g2 = - 20*(x[0]-0.4) * (x[0]-0.6) / 4.8

        out["F"] = [f1, f2]
        out["G"] = [g1, g2]

problem = MyProblem()

algorithm = NSGA2(
    pop_size=40,     # 种群数量
    n_offsprings=10, # 每一代中从父代个体中产生的新个体的数量
    sampling=FloatRandomSampling(), # 用于生成初始种群的采样算子。
    crossover=SBX(prob=0.9, eta=15), # 交叉算法，模拟二进制
    # 交叉概率，分布指数，变异指数，上下限
    mutation=PM(eta=20),  # 变异算子，默认为多项式变异
    eliminate_duplicates=True, # 剔除重复项
)

termination = get_termination("n_gen", 40)

res = minimize(problem,
               algorithm,
               termination,
               seed=1,  # seed 相同就能保证在任何地方执行的结果相同
               save_history=True, # 保存历史
               verbose=True)  # 输出优化过程

X = res.X  # 结果中的自变量
F = res.F  # 结果中的目标量

xl, xu = problem.bounds()
plt.figure(figsize=(7, 5))
plt.scatter(X[:, 0], X[:, 1], s=30, facecolors='none', edgecolors='r')
plt.xlim(xl[0], xu[0])
plt.ylim(xl[1], xu[1])
plt.title("Design Space")
plt.show()

plt.figure(figsize=(7, 5))
plt.scatter(F[:, 0], F[:, 1], s=30, facecolors='none', edgecolors='blue')
plt.title("Objective Space")
plt.show()

四、自定义问题

自定义问题需要解决的关键问题是，算法变量的定义和目标值的输出。

4.1、定义问题

import numpy as np
from pymoo.core.problem import ElementwiseProblem

class MyProblem(ElementwiseProblem):
    def __init__(self, Job,Machine, PT,Jobs_duetime,Jobs_duetime_slack, MachineStart,
                 Jobs_Windows_penalty_Type,TimeWindows_Penalty,Jobs_Wire_Type,Jobs_Frame_Type,xl,xu,**kwargs):
        super().__init__(n_var=Job,
                         n_obj=3,
                         n_ieq_constr=2,# 非等式约束
                         xl=xl,
                         xu=xu,
                         **kwargs)  # 在问题定义时可以设置并行计算的参数
        # https://pymoo.org/problems/parallelization.html

        # 调度优化过程所需参数
        self.Job = Job
        self.Machine = Machine
        self.PT = PT
        self.Jobs_duetime = Jobs_duetime
        self.Jobs_duetime_slack = Jobs_duetime_slack
        self.MachineStart = MachineStart
        self.Jobs_Windows_penalty_Type = Jobs_Windows_penalty_Type
        self.TimeWindows_Penalty = TimeWindows_Penalty
        self.Jobs_Wire_Type = Jobs_Wire_Type
        self.Jobs_Frame_Type = Jobs_Frame_Type
        self.xl = xl
        self.xu = xu

    def _evaluate(self, x, out, *args, **kwargs):
        f1 = 100 * (x[0]**2 + x[1]**2)
        f2 = (x[0]-1)**2 + x[1]**2

        g1 = 2*(x[0]-0.1) * (x[0]-0.9) / 0.18
        g2 = - 20*(x[0]-0.4) * (x[0]-0.6) / 4.8

        out["F"] = [f1, f2]
        out["G"] = [g1, g2]

problem = MyProblem()

其中，f1、f2是关于目标值的计算；

问题定义中的n_ieq_constr=2代表约束为2；

g1、g2是自变量x的约束范围，保证g1,g2≤0。

4.2、问题调用

problem = MyProblem()

五、展望

可以通过Pymoo官方网站找到关于NSGA-III和MOEA/D算法的调用，下面是关于NSGA-III和MOEA/D算法的使用，求解的问题是官网提供案例。

5.1、NSGA-III

相比于NSGA-II，NSGA-III需要加入一个新的参数定义。

5.1.1、需要添加的参数

# create the reference directions to be used for the optimization
ref_dirs = get_reference_directions("das-dennis", 3, n_partitions=12)

5.1.2、补全算法定义部分

# create the reference directions to be used for the optimization
ref_dirs = get_reference_directions("das-dennis", 3, n_partitions=12)

# create the algorithm object
algorithm = NSGA3(pop_size=92,
                  ref_dirs=ref_dirs)

5.1.3、可运行完整代码

from pymoo.algorithms.moo.nsga3 import NSGA3


from pymoo.optimize import minimize
from pymoo.problems import get_problem
from pymoo.util.ref_dirs import get_reference_directions
from pymoo.visualization.scatter import Scatter

# create the reference directions to be used for the optimization
ref_dirs = get_reference_directions("das-dennis", 3, n_partitions=12)

# create the algorithm object
algorithm = NSGA3(pop_size=92,
                  ref_dirs=ref_dirs)

# execute the optimization
res = minimize(get_problem("dtlz1"),
               algorithm,
               seed=1,
               termination=('n_gen', 600))

Scatter().add(res.F).show()

5.2、MOEA/D

5.2.1、需要添加的参数

ref_dirs = get_reference_directions("das-dennis", 3, n_partitions=12)

5.2.2、补全算法定义部分

ref_dirs = get_reference_directions("uniform", 3, n_partitions=12)

algorithm = MOEAD(
    ref_dirs,
    n_neighbors=15,
    prob_neighbor_mating=0.7,
)

5.2.3、可运行完整代码

from pymoo.algorithms.moo.moead import MOEAD
from pymoo.optimize import minimize
from pymoo.problems import get_problem
from pymoo.util.ref_dirs import get_reference_directions
from pymoo.visualization.scatter import Scatter

problem = get_problem("dtlz2")

ref_dirs = get_reference_directions("uniform", 3, n_partitions=12)

algorithm = MOEAD(
    ref_dirs,
    n_neighbors=15,
    prob_neighbor_mating=0.7,
)

res = minimize(problem,
               algorithm,
               ('n_gen', 200),
               seed=1,
               verbose=False)

Scatter().add(res.F).show()

六、参考文献与网站：

1、 重点参考个人笔记网站：Pymoo 多目标优化笔记 | 12Tall

2、 pymoo库源网站：pymoo - 经济部/D

Caidaji
关注
数模4 单目标优化、多目标优化
try_again_later的博客
09-14 1万+
1、优化问题三要素： 决策变量、目标函数、约束 2、单、多目标优化的关系： 多目标优化问题的各个子目标之间是矛盾的 ,一个子目标的改善有可能会引起另一个或者另几个子目标的性能降低 , 也就是要同时使多个子目标一起达到最优值是不可能的 , 而只能在它们中间进行协调和折中处理 , 使各个子目标都尽可能地达到最优化。其与单目标优化问题的本质区别在于 ,它的解并非唯一 ,而是存在一组由众多 Pare...
在Pymoo中实现多任务多目标优化
zhenlingcn的博客
03-19 4584
多任务多目标优化是近年来研究的热点。然而，Pymoo似乎还不支持这种优化范式。因此，在本文中，我打算在Pymoo中实现这个范式。实际上，多任务优化算法还是比较新的领域。总的来说，目前还不清楚哪种算法普遍优于其他算法。根据我目前的知识，[1][2][3]是一些应该考虑的有趣的论文。 在本文中，我将尝试实现一个通用的模板代码，用于在Pymoo中嵌入自定义的多任务策略，而不是实现一个特定的多任务进化算法。 首先，请允许我解释一下我的想法。由于多任务进化优化算法的基本思想是在群体之间交换信息以帮助解决问题，因此我们
pymoo: Python中的多目标优化框架
gitblog_09408的博客
09-13 465
pymoo: Python中的多目标优化框架 pymoo NSGA2, NSGA3, R-NSGA3, MOEAD, Genetic Algorithms (GA), Differential Evolution (DE), CMAES, PSO ...
Python中的优化函数4：pyomo包（功能强，代码直观）
最新发布
辉的博客
03-13 319
Pyomo 是一个用于建模和求解优化问题的 Python 库。它提供了一个灵活的框架，可以用于线性、非线性、整数和混合整数优化问题。Pyomo 允许用户以数学表达式的形式定义优化模型，并支持多种求解器。
多目标优化算法(二)MOEAD（python版）
10-12
本资源为MOEAD的python代码，实验问题为ZDT1,ZDT2,ZDT3,ZDT6,DTLZ1,DTLZ2，实验结果和文档见上一次的资源。
探索进化多目标优化算法-使用Pymoo实现
faithful1的博客
11-20 4038
Pymoo是一个用于多目标优化的Python库。下面我们介绍如何使用Pymoo求解自定义问题。首先，我们需要定义我们自己的问题。我们可以使用Pymoo的Problem类来定义。考虑一个简单的问题：其中，为决策变量。我们要求解这个问题，即求解决策变量的值，使得和的值都最大化，同时满足约束条件。其中，我们定义了一个名为MyProblem的类，继承自Problem。
多目标优化：Pymoo入门实战
weixin_52450371的博客
10-12 4249
多目标优化
Pymoo：使用多目标优化搜索解集的实现方法
嵌入式技术与人工智能
10-19 3157
常见的终止准则是限制函数的迭代次数。此外，一些算法还实现了自己的终止算法，比如，单纯形(simplex)退化时的Nelder Mead算法，或使用CMA-ES算法。✨ **注意，算法收敛性分析(Convergence Analysis)的说明：**收敛性分析能够显示算法在某个时刻算法取得的多大的优化程度。
多目标优化算法源码、遗传算法、粒子群等等多目标优化源码
11-12
本压缩包“pymoo-main”包含了上述提到的多目标优化算法的源码实现。pymoo是一个用Python编写的多目标优化算法库，它为研究人员和工程师提供了一个方便的平台，用于实验、测试和应用多种多目标优化算法。在pymoo中，...
多目标优化算法(四)NSGA3的代码（python3.6）.zip
06-16
总的来说，这个资源提供了使用Python和Matlab实现的多目标优化算法，特别是NSGA3，对于学习和研究多目标优化问题非常有价值。无论是对遗传算法的理解，还是对多目标优化的实际应用，都能从这些源代码中获益。用户...
Genetic:多目标问题和使用pymoo的遗传算法实现
03-16
遗传的 多目标问题和使用pymoo的遗传算法实现
pyMOO-开源
04-26
pyMOO是MOOP（以前称为POO）项目的清理和现代化，旨在在python以及基于Python的健壮客户端中构建健壮，完整且用户友好的MOO实现。
Python库 | pygmo-2.9-cp37-cp37m-manylinux1_x86_64.whl
02-18
python库，解压后可用。 资源全名：pygmo-2.9-cp37-cp37m-manylinux1_x86_64.whl
pymoo-master (1).zip
03-09
遗传算法python框架，内置moead,nsga2,nsga3等python源码。支持多目标和超多目标优化问题。学习python的多目标进化算法经典框架。
pygmo2:一个通过异步广义岛模型执行优化任务（全局和局部）的并行计算的Python平台
05-12
侏儒 pygmo是用于大规模并行优化的科学Python库。 它基于以下思想：为优化算法和优化问题提供统一的接口，并使它们在大规模并行环境中的部署变得容易。 如果您将pygmo用作研究，教学或其他活动的一部分，如果您可以对存储库加注星标和/或引用我们的工作，我们将不胜感激。 出于引用目的，您可以使用以下BibTex条目，该条目引用《开源软件杂志》中的： @article { Biscani2020 , doi = { 10.21105/joss.02338 } , url = { https://doi.org/10.21105/joss.02338 } , year = { 2020 } , publisher = { The Open Journal } , volume = { 5 } , number = { 53 } , pages = { 233
多目标优化算法（四）NSGA3(NSGAIII)论文复现以及matlab和python的代码
热门推荐
晓风
04-01 8万+
多目标优化算法（四）NSGA3(NSGAIII)论文复现以及matlab和python的代码 前沿：最近太忙，这个系列已经很久没有更新了，本次就更新一个Deb大神的NSGA2的“升级版”算法NSGA3。因为multi-objective optimization已经被做烂了，现在学者们都在做many-objective optimization，也就是5个以上的目标函数（悄悄说一句，我觉得这个也要...
python多目标优化_多目标优化算法（四）NSGA3(NSGAIII)论文复现以及matlab和python的代码...
weixin_39707536的博客
12-05 2647
前言：最近太忙，这个系列已经很久没有更新了，本次就更新一个Deb大神的NSGA2的“升级版”算法NSGA3。因为multi-objective optimization已经被做烂了，现在学者们都在做many-objective optimization，也就是5个以上的目标函数(悄悄说一句，我觉得这个也要被做烂了)。此次我是用python复现的，这篇文章也主要以python代码讲解为主。在编写代码...
Pymoo学习 (3)：使用多目标优化找到最优解的集合
因吉的博客
07-21 3530
一个完整的流程展示多目标算法的使用。
pymoo nsga2 导入
01-28
### 正确导入并使用pymoo中的NSGA-II 为了正确导入并使用`pymoo`库中的NSGA-II算法，需遵循标准的Python包导入方式。具体来说，在编写Python脚本时应先引入必要的模块： ```python from pymoo.algorithms.moo.nsga2 import NSGA2 from pymoo.problems import get_problem from pymoo.optimize import minimize ``` 上述代码片段展示了如何从`pymoo`的不同子模块中导入所需的类和函数[^1]。 一旦完成了这些模块的导入，就可以定义要解决的具体优化问题以及所使用的进化算法实例。对于NSGA-II而言，创建其对象的方式如下所示： ```python algorithm = NSGA2() problem = get_problem("zdt1") # 使用ZDT1测试函数作为例子 res = minimize(problem, algorithm, ('n_gen', 200), seed=1, verbose=False) ``` 此段代码说明了怎样设置一个问题实例（这里选择了经典的ZDT1多目标测试函数），指定迭代次数为200代，并调用`minimize()`方法执行实际的优化过程。 如果希望查看官方提供的示例程序，则可以在命令行界面输入以下指令来运行名为`example.py`的样例文件[^2]: ```bash python example.py ``` 需要注意的是，当尝试导入或运行任何第三方库时可能会遇到各种各样的错误消息；针对这种情况建议查阅相关文档获取更多指导信息，也可以参考其他开发者分享的经验贴寻求帮助。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值