差分进化算法库pymoode应用指南

​作者 | Bruno Scalia C. F. Leite

译者 | 朱先忠

审校 | 孙淑娟

差分进化（DE）算法是由Storn&Price在1997年提出的，其最初的设计目的是用于标量目标优化。然而，由于该算法实现的简单性和问题解决质量的高效性，DE已经以多种不同的方式进行了修改，旨在解决多目标优化问题。

在本文中，我们将学习知名的​​开源DE算法库pymoode​​中提供的算法和算子，并使用它开发出一个针对单目标、多目标和多目标优化问题的简单的示例应用程序。目前，此程序已经被部署在PyPI网站上；因此，任何Python用户都可以使用类似于下面简单的命令行进行安装：

pip install pymoode

pymoode软件包是基于另一个开源DE算法库​​pymoo​​（由Blank&Deb在2020年开发）的基本结构而开发的。此库结构上更高效和易于使用，并支持在用户需要时进行高度定制。在此，我极力推荐各位读者认真查看其参考文档并全面了解其可用功能。

此外，朱利安·布兰克（Julian Blank）在Medium网站上撰写的一篇​​优秀文章​​中概括地介绍了遗传算法，其中也介绍了pymoo库的一些特性。

我希望各位都能好好地阅读一下本文，并成功地将pymoode应用到您的一些项目中！而且，感兴趣的朋友也可以遵循本​​示例笔记本程序​​中的所有实现步骤。该软件包也可在​​GitHub​​上轻松获得。

如果你不熟悉差分进化，我建议你先阅读一下我之前写过的一篇文章《差分进化：非线性凸优化的一种替代方法》，地址是：https://towardsdatascience.com/differential-evolution-an-alternative-to-nonlinear-convex-optimization-690a123f3413），以便更好地理解其中的算子。

在我以前撰写的文章中大多专注于探讨一个目标；但在本文中，我们却要同时关注许多问题。

1.pymoode库中的算法与算子

开发pymoode库的主要目的是对pymoo库中的可用算法进行扩展；而且，扩展的重点是围绕差异进化变体展开。因此，这些算法之间将共享再生算子的一些共同特征。此外，我还实现了一些在pymoo中尚不可用的生存算子，为用户提供了更多选项。当然，这些算法和算子可能会被pymoo库的未来版本所涵盖。

截止目前，pymoode库提供的可用算法，列举如下：

• DE算法：由Storn&Price在1997年提出的针对单目标问题的差分进化算法。随后，基于此算法还实现了其他一些特性，例如抖动（dither）、震动（jitter）、选择变体（selection variants）和交叉（crossover）策略。有关详情，请参考Price等人在2005年发表的一些论文。
• NSDE算法：非支配排序差分进化（Non-dominated Sorting Differential Evolution），一种将DE变异和交叉算子结合到NSGA-II（Deb等人，2002）生存算法中的多目标算法。
• GDE3算法：即广义差分进化3，一种多目标算法，将去变异和交叉算子与NSGA-II生存策略相结合，并采用混合型生存策略。在该算法中，在使用多目标生存算子截断种群之前，可以通过一对一比较除去个体。它由Kukkonen，S. &Lampinen和J.在2005年共同提出。
• NSDE-R算法：即Reddy& Dulikravich在2019年发表的基于参考方向的非支配排序差异进化（Non-dominated Sorting Differential Evolution based on Reference directions）。它是一种针对多目标问题的算法，作为NSDE的扩展，使用了NSGA-III（Deb&Jain，2014）生存策略。

pymoode库实现的一些其他的算子包括：

• RankSurvival：以灵活的结构实现了NSGA-II算法的等级和拥挤生存，并提供具有不同的拥挤度量和个体淘汰选项支持。
• ConstrainedRankSurvival：即由Kukkonen，S.，Lampinen和J.四人于2005年共同提出的一种特殊约束条件下基于等级和拥挤的生存算子（A survival operator based on rank and crowding with a special constraint handling approach），实现了特殊的约束处理方法。

可用的拥挤度量指标包括：

• Crowding Distance (‘cd’)：由Deb等人在2002年在NSGA-II算法中提出，可以从pymoo库导入。
• Crowding Entropy (‘ce’)：由Wang等人在2009年在MOSADE算法中提出。
• M-Nearest Neighbors (‘mnn’)：由Kukkonen & Deb于2006年在一篇针对GDE3算法的扩展文章中提出，用于解决多目标问题（这里“M”对应目标的数量）。
• 2-Nearest Neighbors (‘2nn’)：也是由Kukkonen & Deb (2006a)提出的，是M-Nearest Neighbors的一个变体，其中的邻居数被设置为2。

2.DE算法概述和控制参数

DE算法的基本结构如下图所示。接下来，将介绍pymoode中实现的最重要的控制参数。有关更多详细信息，建议阅读我之前撰写的那篇​​关于DE的文章​​和Price等人于2005年合著的有关书籍。

DE算法的基本结构。

• pop_size (int类型，可选参数)：人口规模。
• sampling (Sampling，Population或者类数组类型，可选参数)：指示pymoo库中使用的抽样策略。
• variant (str类型，可选参数)：差异进化策略。必须是以下格式的字符串：“DE/selection/n/crossover”；默认值为“DE/rand/1/bin”。
• CR (float类型，可选参数)：交叉参数，在范围[0，1]中定义。为了加强变异，可以使用更高的值；但是，为了控制收敛速度，应使用较小的值。
• F (可迭代的float类型或者是float类型，可选参数)：比例因子或变异参数，取值范围是（0，2]。若要加强探索（exploration）难度，请使用较高的值；而对于开发（exploitation）难度，请使用较低的值。
• gamma (float类型，可选参数)：震动（jitter）偏差参数，取值范围是(0, 2)，默认值为1E-4。
• pm (Mutation, optional)：Pymoo实现交叉计算后的变异算子，默认值为None。
• repair (callable类型或者str类型)：问题边界外突变向量的修复策略，所采用的策略基于Price等人于2005年发表的论文。默认值为“bounce-back”。
• survival (Survival类型，可选参数)：Pymoo的生存策略，在多目标算法中应该注意此参数的取值。

在选择DE的控制参数时，我建议优先考虑pop_size、variant、CR和F这四个参数。有关文献中报道，当使用非常小的总体规模时，抖动非常有用（Price等人在2005年的论文）；在这种情况下，可能需要使用更高的伽马值。我发现它对于在帕累托前沿串联线性段的情况也很有用。参数pm表示可能在交叉后执行的pymoo变异。当使用强化开发和精英主义的变体（如DE/best）时，使用多项式变异非常有用。

repair参数选择问题边界外的突变向量所采用的修复策略。此参数可以作为callable类型或字符串类型传递。目前的实现算法中使用了Price等人（2005年）提出的备选方案。默认的反弹（bounce-back）策略将违反边界的变量设置为相应的去突变基向量和变量边界之间的随机值；在类似的策略中，midway参数将值重置为两者之间的中间点。策略参数rand-init在问题边界之间随机抽取一个新值，用于违反决策变量，这有助于增强多样性，尽管它会破坏接近边界的解决方案的进程。生存策略对多目标类型算法是有效的，而单目标DE算法使用的是经典的一对一替换方案。

在下一节中，让我们使用pymoo库中的结构开始定义一个问题。

3.在pymoo中定义问题

在pymoo中，定义问题有三种不同的方法。所有这三种方法都创建一个继承自Problem类的实例。​​pymoo官方文档​​中作出如下描述：

• Problem类：面向对象的定义，它实现了一种评估一组解决方案的方法。
• ElementwiseProblem类：面向对象的定义，它实现了一个函数，一次评估一个解决方案。
• FunctionalProblem：通过为每个目标和约束使用函数来定义问题。

from pymoo.core.problem import Problem, ElementwiseProblem
from pymoo.problems.functional import FunctionalProblem

接下来，我将分别使用上面三种方法来展示如何解决同一优化问题。

第一个示例将基于Rastrigin函数的单目标优化问题。这是一个常见的非凸优化单目标测试问题，因为它包含多个局部最优解。这可以通过以下等式来进行描述。

Rastrigin问题使用的等式

其中，A是一个用户指定的参数（通常为10），n是使用的决策变量数。在我们的实现中，我们将使用两个决策变量，这两个变量均以-5.12和5.12为界。

也许，定义问题最直观的方法是使用函数式编程，我们的定义代码如下所示：

#定义目标函数
def rastrigin(x):
    return np.sum(x * x - \
        10 * np.cos(2 * np.pi * x)) \
            + 10 * np.size(x)#函数式编程
functional_problem_1 = FunctionalProblem(
    n_var=2, objs=rastrigin,
    xl=np.full(2, -5.12), xu=np.full(2, 5.12),
    constr_ieq=[])

或者，相同的问题可以定义为一个ElementwiseProblem，如下所示：

class ElementwiseF1(ElementwiseProblem):
def __init__(self):
        xl = np.full(2, -5.12)
        xu = np.full(2, 5.12)
        super().__init__(
            n_var=2, n_obj=1, n_constr=0,
            xl=xl, xu=xu)
def _evaluate(self, x, out, *args, **kwargs):
        out["F"] = rastrigin(x)

或作为一个Problem，定义为以一个矢量化的方式评估一组解决方案。

class ProblemF1(Problem):
def __init__(self):
        xl = np.full(2, -5.12)
        xu = np.full(2, 5.12)
        super().__init__(
            n_var=2, n_obj=1, n_constr=0,
            xl=xl, xu=xu)
    def _evaluate(self, x, out, *args, **kwargs):
        out["F"] = np.sum(x * x - \
            10 * np.cos(2 * np.pi * x), axis=1) \
                + 10 * x.shape[1]

注意，上面Problem结构中的x是一个数组，对应于形状为（N，m）的总体中的决策变量。其中，N对应于总体大小，m对应于决策变量的数量。

在下一节中，我们将使用单目标DE算法的pymoode库实现方案来解决这个问题。

4.单目标DE算法

为了解决Rastrigin问题，我们首先要导入一些有用的算子。它们分别是算法（DE）、minimize 接口和单目标终止算子（SingleObjectiveDefaultTermination）。

from pymoode.de import DE
from pymoo.optimize import minimize
from pymoo.util.termination.default import \
    SingleObjectiveDefaultTermination

我们将用如下方式实例化DE类的第一个实例。

de = DE(pop_size=30, variant="DE/rand/1/bin", F=(0.3, 1.0), CR=0.5)

这是一个低维问题，尽管由于存在许多局部最优解而具有挑战性。因此，我使用30作为人口规模N，以确保全局收敛。DE参数指定为最常用的“DE/rand/1/bin”，F参数指定为（0.3，1.0）——使用随机均匀分布抖动，CR参数设置为0.5，以加强坐标轴上的搜索并控制收敛。

我没有为这个问题调整控制参数；因此，其它的参数组合可能更有效一些。如果有对DE的工作方式感兴趣的读者，建议您阅读一下我​​以前写的一篇文章​​，在这篇文章中我对DE的工作方式进行了详细的描述。

接下来，让我们根据f (f_tol)、 x (x_tol)、约束冲突（cv_tol）和最大世代数（n_max_gen）的变化来定义终止条件。参数nth_gen用于控制检查终止条件的频率，参数n_last则用于控制评估变化时需要考虑的前几代的数量。

termination_1 = SingleObjectiveDefaultTermination(
    x_tol=1e-6,
    cv_tol=0.0,
    f_tol=1e-6,
    nth_gen=5,
    n_last=20,
    n_max_gen=100)

接下来，让我们开始使用minimize接口来解决问题。

res_de_problem_1 = minimize(
    ProblemF1(),
    de,
    termination=termination_1,
    seed=12,
    save_history=True,
    verbose=False)

该算法是有效的，它能够让我们找到函数的全局最优解，即目标函数也为零的x中的零向量。

因为我们已将参数save_history指定为True；所以，现在我们可以访问世代的人口属性，而且可以创建如下所示的视觉效果。

Rastrigin问题中世代人口的演变图示（原文为动画，此处仅取一帧）

需要注意的是，为了创建上述动画效果，我使用了​​pyrecorder库​​。

［译者注］pyrecorder是Github上的一个开源Python动画录制库，当使用Matplotlib、Plotly和其他绘图库制作动画是一个得力的工具。

5.多目标优化简介

顾名思义，多目标优化涉及同时优化多个目标。当目标相互冲突时，即一个目标函数的最优解与另一个目标函数的最优解不同时，问题变得具有挑战性。在解决此类问题时，无论是否存在约束，这些问题都会产生一组权衡最优解，通常称为帕累托最优解。由于解决方案的多样性，建议在搜索过程中,使用种群方法的进化算法来适当解决这些问题（Deb，2011）。

帕累托最优解可以用支配（Domination）的概念来理解。它们是特定人群中不受任何其他人支配的解决方案。

根据Deb（2001）论文中描述的，如果解决方案x1支配解决方案x2，那么：

• x1在所有目标上都不比x2差。
• x1在至少一个目标上严格优于x2。

已经提出了一些处理约束的想法。通常的方法是Deb等人于2002年在NSGA-II算法中采用的方法。其中，可行解总是优于不可行解；而且，不可行解按总体约束违反程度进行排序。

两目标极小化问题的帕累托最优解如下所示：

帕累托最优解示意图

生存算子必须强调好的解决方案，而不是坏的解决方案。在现代多目标算法中，非支配排序（或类似的操作）几乎总是存在的，它根据支配标准将每个解归属于一个排名。排名按从最佳到最差的解决方案升序排列，通常是第一个生存标准。

非支配排序示意图

当超过种群规模时，具有相同等级的个体按几种策略进行排序。其中，两种常见策略是NSGA-II中的拥挤距离（Deb等人论文，2002）和NSGA-III中的参考方向（Deb&Jain论文，2014）。

默认情况下，在pymoode算法中GDE3和NSDE都使用的是与NSGA-II相同的生存策略，而NSDE-R使用与NSGA-III相同的生存策略。

在下一节中，我们将使用GDE3、NSDE和NSGA-II（在pymoo中实现）解决一个多目标问题。

6.多目标算法：GDE3和NSDE

GDE3和NSDE是生存阶段使用非支配排序和拥挤指标的DE算法的两个多目标变体。尽管它们的生存策略不同，但它们拥有相同的繁殖算子。

NSDE使用完整（µ+λ）生存策略，将父代群体与子代结合在一起，而GDE3在将群体截断为原始大小之前，对父代群体中的每个成员及其相应的试验载体进行一对一比较。在这种一对一的比较中，如果一对个体占优势，那么在（µ+λ）存活之前，每对个体中的一个个体可能会提前从组合群体中移除。

对于大多数问题，GDE3和NSDE将导致非常相似的结果。在某些问题中，NSDE可能会稍微快一些，而GDE3在使用低CR值时可能会更好地避免过早收敛。

首先，让我们导入本节中使用的算子：

#算法
from pymoode.gde3 import GDE3
from pymoode.nsde import NSDE
from pymoo.algorithms.moo.nsga2 import NSGA2#终止
from pymoo.util.termination.default import \
    MultiObjectiveDefaultTermination

在这个例子中，我将引入两个相互冲突的凸目标，并通过约束引入额外的困难。该问题将在两个决策变量x1和x2上定义，这两个变量均以-5.0和5.0为界。

多目标示例程序中使用的目标函数

多目标示例程序中使用的约束函数

在Python编程中，可以使用pymoo库的Problem结构来实现：

class ProblemF2(Problem):    def __init__(self):      xl = np.full(2, -5.0)
      xu = np.full(2, 5.0)
      super().__init__(n_var=2, n_obj=1, n_constr=2, xl=xl, xu=xu)    def _evaluate(self, x, out, *args, **kwargs):        F1 = (x[:, 0] - 0.5) ** 2 + 0.7 * x[:, 0] * x[:, 1] \
            + 1.2 * (x[:, 1] + 0.7) ** 2
        F2 = 1.1 * (x[:, 0] + 1.5) ** 2 + 0.8 * x[:, 0] * x[:, 1] \
            + 1.3 * (x[:, 1] - 1.7) ** 2
        out["F"] = np.column_stack([F1, F2])        G1 = x[:, 0] ** 2 + (x[:, 1] - 1) ** 2 - 9
        G2 = - (x[:, 0] + 0.5) ** 2 - (x[:, 1] - 1) ** 2 + 2
        out["G"] = np.column_stack([G1, G2])

然后，让我们定义终止条件。由于这是一个多目标问题，f和x的差异就不那么直观了。在pymoo中，IGD指标用于评估两个不同世代f和x之间的差异。执行此定义只是为了说明MultiObjectiveDefaultTermination算子的工作方式。

termination_multi = MultiObjectiveDefaultTermination(
    x_tol=1e-8,
    cv_tol=1e-8,
    f_tol=1e-8,
    nth_gen=5,
    n_last=50,
    n_max_gen=200)

在解决这个问题时，除了GDE3和NSDE之外，我们还将使用pymoo库中的NSGA-II算法。在此，我依旧没有调整DE算法的控制参数；因此，算法作者可能已经作了改进。在NSGA-II算法中，采用了模拟二进制交叉和多项式变异的默认控制参数，这些参数默认情况下都是可选的关键字参数。

gde3 = GDE3(pop_size=50, variant="DE/rand/1/bin",\
    F=(0.0, 1.0), CR=0.7)nsde = NSDE(pop_size=50, variant="DE/rand/1/bin",\
    F=(0.0, 1.0), CR=0.7)nsga2 = NSGA2(pop_size=30)

一旦我们定义了算法和问题，接下来让我们使用minimize接口来解决问题。

res_gde3_problem_2 = minimize(
    ProblemF2(),
    gde3,
    termination_multi,
    seed=12,
    save_history=True,
    verbose=False)

所有算法的过程都是一样的，只是改变了一下传递给minimize函数的第二个参数。因此，有关其他算法的实现代码在此不再展示。

三种算法得到的帕累托前沿如下所示。

多目标示例程序中得到的帕累托前沿示意图

我们注意到，这三种算法收敛到大致相同的区域。在这个简单的示例中，这可能是真正的前沿的邻域。

有好几个指标可以用来比较多目标问题的性能问题。例如，最常见的有世代距离（Generational Distances）、反向世代距离（Inverted Generational Distances）和超体积（Hypervolume）算法。它们都是在pymoo库中通过示例程序实现的。由于在这个问题中，真实前沿是先验未知的，所以我只使用了超体积来比较算法性能。

​​示例笔记本源程序​​中提供了完整的实现，主要结果总结如下：

hv GDE3 0.753470843848252
hv NSDE 0.752272658484699
hv NSGA-II 0.7527205037080124

虽然GDE3稍好一些，但这三种算法的性能非常相似。估计在一些独立运行的情况下，这不会带来统计学方面的重要影响。

为了说明进化过程，我使用了针对GDE3解决方案的pyrecorder来生成简短的动画。在动画中，针对前70代在决策变量和目标空间中都有相应的说明。

基于GDE3的多目标例程的决策空间进化过程动画展示。（此处仅取一帧）

基于GDE3的多目标示例在目标空间中的动画演化过程。（此处仅取一帧）

人们可能会认为，通过评估之前的图像和动画，帕累托前沿可能会更平滑……这是真的，与原始策略相比，排名和拥挤生存的一些变体的确表现出了优异的性能。为了在生存阶段为用户提供更多选项，在pymoode库中还提供了一个RankSurvival类。

为提高多样性而采取的一种相关策略是递归地消除个体并重新计算拥挤指标，而不是根据整个前沿的拥挤指标立即消除最后前沿上超过人口规模的所有个体。针对此问题，Kukkonen&Deb（2006b）对修改后的策略进行了深入分析。

迄今为止，pymoode库已经实现了三种不同的方法，用于移除个体：

• full：立即从最后前沿上清除所有超过人口规模的个体。
• single：一次递归删除一个个体，在每次消除时重新计算拥挤指标。
• sqrt：递归移除超过总体规模的个体数平方根的整数部分，在每次消除时重新计算拥挤度量。

由于Python本身执行时间长，这些策略尚未以最有效的方式实现。我打算将来为它们提供更有效的方法。也许使用Cython实现会有所帮助。

目前，可以按以下方式执行。

#导入生存算子
from pymoode.survivors import RankSurvival#使用相应的消除规则和拥挤度量实例化RankSurvival
survival = RankSurvival(rule="single", crowding_func="cd")#传递给算法中的survival参数
gde3 = GDE3(pop_size=100, survival=survival)

7.多目标算法：NSDE-R和GDE3-MNN

由于GDE3和NSDE最初是使用NSGA-II等级和拥挤生存进行设计的，这导致它们在许多客观问题上表现不佳。然而，从用户角度进行简单的修改可以解决这个问题。

NSDE-R（Reddy&Dulikravich，2019）将NSGA-III的生存算子与DE的再生算子结合在一起，在许多客观问题上都表现出色。GDE3-MNN是Kukkonen和Deb（2006a）提出的GDE3算法的一个变体，它用基于M近邻的拥挤度量取代了原始的排名和拥挤生存距离，并使用递归消除和重新计算。它在多目标问题上大大提高了GDE3算法的性能。

特别是在多目标问题中，由于目标空间的稀疏性，当使用相同的生存策略时，NSDE和GDE3会产生比两个目标问题更相似的结果。因此，在本节中，将只考虑实现每种算法的一个变量的简单情况。

除了实现DE算法之外，我们还将实现NSGA-III算法，它是多目标优化中最成功的算法之一。

首先，让我们导入相应的算子：

#算法
from pymoode.nsder import NSDER
from pymoo.algorithms.moo.nsga3 import NSGA3#导入测试问题并获取参考方向的接口
from pymoo.factory import get_reference_directions, get_problem

在本例中，我将使用get_problem接口导入在pymoo中实现的多目标问题，也就是​​DTLZ2​​。其中，x中的每个组件都定义在范围[0，1]内，并且没有指定约束函数。

以下等式描述了这些目标：

DTLZ2问题的目标函数

让我们举例说明本节中使用的算法。请注意，参考方向无论在NSDE-R算法还是在NSGA-III算法中都是一个必需的参数。幸运的是，pymoo有一个接口可以轻松获得常用方向。此外请注意，在GDE3中，在使用RankSurvival算子时经常与crowding_func = “mnn”一起使用，这里使用了前面提到的M-NN策略。

#定义参考方向
ref_dirs = get_reference_directions(
    "das-dennis", 3, n_partitions=15)#NSGA-III建议
popsize = ref_dirs.shape[0] + ref_dirs.shape[0] % 4nsder = NSDER(ref_dirs, pop_size=popsize,
    variant="DE/rand/1/bin", F=(0.0, 1.0), CR=0.5)gde3mnn = GDE3(pop_size=popsize,
    variant="DE/rand/1/bin", F=(0.0, 1.0), CR=0.2,
    survival=RankSurvival(crowding_func="mnn"))nsga3 = NSGA3(ref_dirs, pop_size=popsize)

在本节中，我将采用一个简化版本的结束条件（‘n_gen’, 250），仅基于世代数，这对于多目标问题来说是常见的。

res_nsder_problem_3 = minimize(
    get_problem("dtlz2"),
    nsder,
    ('n_gen', 250),
    seed=SEED,
    save_history=True,
    verbose=True)

NSGA-III在这个问题上的表现优于DE算法，尽管DE算法的性能也很好，尤其是NSDE-R。

通过算法完成后获得的帕累托前沿如下图所示：

通过DTLZ2算法获得的帕累托前沿示意

现在，我们已经通过pymoode库中提供的算子解决了上述好几个不同的问题。

8.应用和前景

目前，多目标进化算法已被广泛应用于许多不同领域，包括投资组合优化（Zhao等合著论文，2020）、电厂运营（Wang等合著论文，2014）、配水系统（Monsef等合著论文，2019）和网络控制（Gonçalves等合著论文，2022）等。此外，在工程过程设计和控制方面也有很多应用；作为一名化学工程师，我就是从这种应用软件的开发开始的。

我第一次遇到多目标进化算法是为我的第一篇关于苯乙烯反应器模拟和优化的文章做文献回顾（Leite等人，2021）。Yee等人（2003）使用Srinivas&Deb（1994）的原始NSGA算法对该问题进行了首次应用开发。它产生了巨大的成果，后来推动了Tarafader等人（2005）的研究，该研究除了增加了问题公式的复杂性，以便将更多的过程纳入目标之外，还采用了更有效的算法：NSGA-II（Deb等人，2002）。Babu等人的论文（2005）和Gujarathi&Babu等人的论文（2010）也提出了苯乙烯反应器问题的多目标差分进化方法。

看到这些算法在过去几十年中如何得到改进并提供给用户，我感到非常惊讶。pymoode软件包一开始试图通过进化方法优化复杂的反应堆仿真模型，但现在我相信它已经变得更加复杂，因为它为任何Python用户提供了迄今为止提出的一些最有效的差分进化算法和工具。

9.总结

在本文中，我们学习了著名的Python开源包pymoode所实现的主要功能，并进一步了解到此包可用于解决单目标、多目标和多目标优化等问题。该软件包是pymoo的一个扩展，专注于差分进化算法，并提供了多种算子，可确保出色的性能并支持高度定制。最后，本文中的所有示例代码都可以从​​Github​​上下载。注意，pymoode库提出的一些新特性有可能稍后被pymoo库合并到其中。

原文链接：https://towardsdatascience.com/pymoode-differential-evolution-in-python-78e4221e5cbe

译者介绍

朱先忠，51CTO社区编辑，51CTO专家博客、讲师，潍坊一所高校计算机教师，自由编程界老兵一枚。早期专注各种微软技术（编著成ASP.NET AJX、Cocos 2d-X相关三本技术图书），近十多年投身于开源世界（熟悉流行全栈Web开发技术），了解基于OneNet/AliOS+Arduino/ESP32/树莓派等物联网开发技术与Scala+Hadoop+Spark+Flink等大数据开发技术。​