算法列表#
用Python实现的算法#
- class pygmo.scipy_optimize(args=(), method: typing.Optional[str] = None, tol: typing.Optional[float] = None, callback: typing.Optional[typing.Callable[[typing.Any], typing.Any]] = None, options: typing.Optional[typing.MutableMapping[str, typing.Any]] = None, selection: pygmo.core.s_policy = Selection policy name: Select best C++ class name: pagmo::select_best Extra info: Absolute migration rate: 1 )#
该类是一个用户定义的算法（UDA），提供了对函数
scipy.optimize.minimize()的封装。这封装了几种著名的局部优化算法：
内尔德-米德
鲍威尔
CG
BFGS
牛顿共轭梯度法
L-BFGS-B
TNC
COBYLA
SLSQP
信任约束
狗腿
信任-非线性共轭梯度
信任-精确
信任-克雷洛夫
这些方法大多是梯度下降的变体。其中一些方法需要梯度，如果在一个不提供梯度的问题上调用，将会抛出错误。只有COBYLA、SLSQP和trust-constr方法支持约束。
示例：
>>> import pygmo as pg >>> prob = pg.problem(pg.rosenbrock(10)) >>> pop = pg.population(prob=prob, size=1, seed=0) >>> pop.champion_f[0] 929975.7994682974 >>> scp = pg.algorithm(pg.scipy_optimize(method="L-BFGS-B")) >>> result = scp.evolve(pop).champion_f >>> result[0] 1.13770... >>> pop.problem.get_fevals() 55 >>> pop.problem.get_gevals() 54
构造函数为特定算法初始化一个包装器实例。 构造参数是那些不特定于问题的
scipy.optimize.minimize()选项。 特定于问题的选项，例如边界、约束以及梯度和海森矩阵的存在， 是从传递给进化函数的问题群体中推导出来的。- Parameters
args – 可选 - 用于适应可调用函数的额外参数
method – 可选 - 字符串，指定scipy使用的方法。根据scipy文档：“如果未给出，则根据问题是否有约束或边界选择BFGS、L-BFGS-B、SLSQP之一。”
tol – 可选 - 终止的容差
callback – 可选的 - 在每次迭代中调用的可调用对象，独立于适应度函数
options – 可选的 - 特定求解器的选项字典
selection – 可选 - s_policy 用于选择本地优化的候选者
- Raises
ValueError – 如果方法不是Nelder-Mead Powell、CG、BFGS、Newton-CG、L-BFGS-B、TNC、COBYLA、SLSQP、trust-constr、dogleg、trust-ncg、trust-exact、trust-krylov或None之一。
- evolve(population)#
使用种群中的随机成员作为起始值调用 scipy.optimize.minimize。
问题是从人口中提取的，其适应度函数为优化过程提供了目标值。
- Parameters
population – 包含问题和一组初始解的种群。
- Returns
改变的人口。
- Raises
ValueError – 如果问题有约束条件，但在构建过程中选择了一个无法处理这些约束条件的方法。
ValueError – 如果问题包含多个目标
ValueError – 如果问题是随机的
未指定 – 由问题的成员函数抛出的任何异常
- set_verbosity(level: int) None#
修改选项字典中的‘disp’参数，该参数会打印出最终的收敛信息。
- Parameters
level – 每个大于零的详细级别都会打印出收敛消息。
- Raises
ValueError – 如果在实例构造函数中提供了选项字典，并且这些选项与详细级别冲突
从C++暴露的算法#
- class pygmo.null_algorithm#
空算法。
用于
pygmo.algorithm和元算法的默认初始化中的算法。
- class pygmo.gaco(gen = 1, ker = 63, q = 1.0, oracle = 0., acc = 0.01, threshold = 1u, n_gen_mark = 7u, impstop = 100000u, evalstop = 100000u, focus = 0., memory = false, seed = random)#
扩展蚁群优化算法 (gaco)。
蚁群优化是一类模拟蚁群行为的优化算法。人工“蚂蚁”（例如模拟代理）通过遍历代表所有可能解决方案的参数空间来定位最优解。真实的蚂蚁在探索环境时会释放信息素，引导彼此找到资源。模拟的“蚂蚁”同样记录它们的位置和解决方案的质量，以便在后续的模拟迭代中，更多的蚂蚁能够找到更好的解决方案。
在pygmo中，我们提出了一个称为扩展ACO的算法版本，最初由Schlueter等人描述。 扩展ACO通过使用基于三个参数（即信息素值）的多核高斯分布来生成未来的蚂蚁种群， 这些参数根据每个先前解决方案的质量计算得出。解决方案通过oracle惩罚方法进行排名。
该算法可以应用于箱型约束的单目标、有约束和无约束优化问题，适用于连续和整数变量。
注意
在PaGMO中实现的ACO版本是Schlueter最初提出的扩展ACO算法的扩展。 实现版本与原始版本之间的主要区别在于 如何计算三个信息素值中的两个（特别是权重和标准差）。
另请参阅
Schlueter, 等人. (2009). 扩展蚁群优化用于非凸混合整数非线性规划. 计算机与运筹学.
- Parameters
- Raises
OverflowError – 如果 gen 或 seed 为负数或大于实现定义的值
ValueError – 如果 acc 不小于0，focus 不小于0 或 q 不小于0， threshold 不在 [1,gen] 范围内当 gen!=0 且 memory==false 时，或 threshold 不小于1 当 gen!=0 且 memory==true 时
另请参阅C++类
pagmo::gaco的文档。- get_log()#
返回一个日志，包含上次调用
evolve()时记录的相关参数并打印到屏幕上。日志频率取决于详细程度参数（默认情况下不记录任何内容），可以通过在构造的algorithm上调用方法set_verbosity()来设置，该算法使用gaco构建。详细程度为N意味着每N代记录一行日志。- Returns
at each logged epoch, the values
Gen,Fevals,Best,Kernel,Oracle,dx,dp, where:Gen(int), generation numberFevals(int), number of functions evaluation madeBest(float), best fitness function valueKernel(int), kernel sizeOracle(float), oracle parameterdx(float), sum of the absolute value of the difference between the variables’ values of the best and worst solutionsdp(float), absolute value of the difference between the worst and best solutions’ penalty values
- Return type
示例
>>> import pygmo as pg >>> prob = pg.problem(pg.rosenbrock(dim = 2)) >>> pop = pg.population(prob, size=13, seed=23) >>> algo = pg.algorithm(pg.gaco(10, 13, 1.0, 1e9, 0.0, 1, 7, 100000, 100000, 0.0, False, 23)) >>> algo.set_verbosity(1) >>> pop = algo.evolve(pop) Gen: Fevals: Best: Kernel: Oracle: dx: dp: 1 0 179.464 13 1e+09 13.1007 649155 2 13 166.317 13 179.464 5.11695 15654.1 3 26 3.81781 13 166.317 5.40633 2299.95 4 39 3.81781 13 3.81781 2.11767 385.781 5 52 2.32543 13 3.81781 1.30415 174.982 6 65 2.32543 13 2.32543 4.58441 43.808 7 78 1.17205 13 2.32543 1.18585 21.6315 8 91 1.17205 13 1.17205 0.806727 12.0702 9 104 1.17205 13 1.17205 0.806727 12.0702 10 130 0.586187 13 0.586187 0.806727 12.0702 >>> uda = algo.extract(pg.gaco) >>> uda.get_log() [(1, 0, 179.464, 13, 1e+09, 13.1007, 649155), (2, 15, 166.317, 13, 179.464, ...
另请参阅相关C++方法的文档
pagmo::gaco::get_log()。
- class pygmo.maco(gen=1, ker=63, q=1.0, threshold=1, n_gen_mark=7, evalstop=100000, focus=0., memory=False, seed=random)#
多目标蚁群优化器 (MACO).
- Parameters
- Raises
OverflowError – 如果 gen 或 seed 为负数或大于实现定义的值
ValueError – 如果 focus 小于 0，或者当 gen 大于 0 且 memory 为 False 时 threshold 不在 [0,*gen*] 范围内，或者当 gen 大于 0 且 memory 为 True 时 threshold 不小于 1
另请参阅C++类
pagmo::maco的文档。- get_log()#
返回一个日志，包含上次调用
evolve()时记录的相关参数并打印到屏幕上。日志频率取决于详细程度参数（默认情况下不记录任何内容），可以通过在构造algorithm时调用set_verbosity()方法来设置。详细程度为N意味着每N代记录一行日志。- Returns
在每个记录的时期，值
Gen,Fevals,ideal_point，其中：- Return type
示例
>>> from pygmo import * >>> algo = algorithm(maco(gen=100)) >>> algo.set_verbosity(20) >>> pop = population(zdt(1), 63) >>> pop = algo.evolve(pop) Gen: Fevals: ideal1: ideal2: 1 0 0.0422249 2.72416 21 1260 0.000622664 1.27304 41 2520 0.000100557 0.542994 61 3780 8.06766e-06 0.290677 81 5040 8.06766e-06 0.290677 >>> uda = algo.extract(maco) >>> uda.get_log() [(1, 0, array([0.04222492, 2.72415949])), (21, 1260, array([6.22663991e-04, ...
另请参阅相关C++方法的文档
pagmo::maco::get_log()。
- class pygmo.gwo(gen=1, seed=random)#
灰狼优化器 (gwo)。
灰狼优化器是一种基于灰狼的领导层级和狩猎机制的优化算法，由Seyedali Mirjalilia、Seyed Mohammad Mirjalilib和Andrew Lewis于2014年提出。
该算法是一个经典例子，展示了在本世纪头几十年中，一种备受批评的搜索思路如何催生了一整套启发式优化方法的隐喻动物园。在我们看来，这些方法，如灰狼优化器，往往只是对已有启发式方法的小幅改动，却冠以不必要且复杂的生物学隐喻。以GWO为例，其位置更新规则极其简单，也可以轻易视为进化隐喻或粒子群隐喻的产物。这样的更新规则并不特别有效，大多数情况下表现欠佳。阅读原始的同行评审论文，其中通过所展示基准测试的方法论缺陷掩盖了算法性能的不足，让人对整个同行评审系统留下了苦涩的印象。
该算法可以应用于具有连续值的箱型边界单目标、有约束和无约束优化。
- Parameters
- Raises
OverflowError – 如果 gen 或 seed 为负数或大于实现定义的值
ValueError – 如果 gen 不大于等于3
另请参阅C++类
pagmo::gwo的文档。- get_log()#
返回一个日志，包含上次调用
evolve()时记录的相关参数并打印到屏幕上。日志频率取决于详细程度参数（默认情况下不记录任何内容），可以通过在构造的algorithm上调用方法set_verbosity()来设置，该算法使用gwo构建。详细程度为N意味着每N代记录一行日志。- Returns
在每个记录的时期，值
Gen,Fevals,ideal_point，其中：- Return type
示例
>>> from pygmo import * >>> algo = algorithm(gwo(gen=10)) >>> algo.set_verbosity(2) >>> prob = problem(rosenbrock(dim=2)) >>> pop = population(prob, size=13, seed=23) >>> pop = algo.evolve(pop) Gen: Alpha: Beta: Delta: 1 179.464 3502.82 3964.75 3 6.82024 30.2149 61.1906 5 0.321879 2.39373 3.46188 7 0.134441 0.342357 0.439651 9 0.100281 0.211849 0.297448 >>> uda = algo.extract(gwo) >>> uda.get_log() [(1, 179.46420983829944, 3502.8158822203472, 3964.7542658046486), ...
另请参阅相关C++方法的文档
pagmo::gwo::get_log()。
- class pygmo.bee_colony(gen=1, limit=1, seed=random)#
人工蜂群算法。
- Parameters
- Raises
OverflowError – 如果 gen、limit 或 seed 为负数或大于实现定义的值
ValueError – 如果 limit 不大于 0
另请参阅C++类
pagmo::bee_colony的文档。- get_log()#
返回一个日志，包含上次调用
evolve()期间记录的相关参数。日志频率取决于详细程度参数（默认情况下不记录任何内容），可以通过在构造的algorithm上调用方法set_verbosity()来设置，该算法使用bee_colony构建。详细程度为N意味着每N代记录一行日志。- Returns
在每个记录的周期中，值
Gen,Fevals,Current best,Best, 其中：- Return type
示例
>>> from pygmo import * >>> algo = algorithm(bee_colony(gen = 500, limit = 20)) >>> algo.set_verbosity(100) >>> prob = problem(rosenbrock(10)) >>> pop = population(prob, 20) >>> pop = algo.evolve(pop) Gen: Fevals: Best: Current Best: 1 40 261363 261363 101 4040 112.237 267.969 201 8040 20.8885 265.122 301 12040 20.6076 20.6076 401 16040 18.252 140.079 >>> uda = algo.extract(bee_colony) >>> uda.get_log() [(1, 40, 183727.83934515435, 183727.83934515435), ...
另请参阅相关C++方法的文档
pagmo::bee_colony::get_log()。
- class pygmo.de(gen=1, F=0.8, CR=0.9, variant=2, ftol=1e-6, xtol=1e-6, seed=random)#
差分进化
- Parameters
- Raises
OverflowError – 如果 gen、variant 或 seed 为负数或大于实现定义的值
ValueError – 如果 F, CR 不在 [0,1] 范围内或 variant 不在 [1, 10] 范围内
以下变体（突变变体）可用于创建新的候选个体：
1 - 最佳/1/指数
2 - 随机/1/指数
3 - 随机到最佳/1/指数
4 - 最佳/2/指数
5 - 随机数/2/指数
6 - 最佳/1/二进制
7 - 随机/1/二进制
8 - 随机到最佳/1/二进制
9 - 最佳/2/二进制
10 - 随机/2/二进制
另请参阅C++类
pagmo::de的文档。- get_log()#
返回一个包含上次调用
evolve()期间记录的相关参数的日志。日志频率取决于详细程度参数（默认情况下不记录任何内容），可以通过在构造的algorithm上调用方法set_verbosity()来设置。详细程度为N意味着每N代记录一行日志。- Returns
at each logged epoch, the values
Gen,Fevals,Best,dx,df, where:Gen(int), generation numberFevals(int), number of functions evaluation madeBest(float), the best fitness function currently in the populationdx(float), the norm of the distance to the population mean of the mutant vectorsdf(float), the population flatness evaluated as the distance between the fitness of the best and of the worst individual
- Return type
示例
>>> from pygmo import * >>> algo = algorithm(de(gen = 500)) >>> algo.set_verbosity(100) >>> prob = problem(rosenbrock(10)) >>> pop = population(prob, 20) >>> pop = algo.evolve(pop) Gen: Fevals: Best: dx: df: 1 20 162446 65.2891 1.78686e+06 101 2020 198.402 8.4454 572.161 201 4020 21.1155 2.60629 24.5152 301 6020 6.67069 0.51811 1.99744 401 8020 3.60022 0.583444 0.554511 Exit condition -- generations = 500 >>> uda = algo.extract(de) >>> uda.get_log() [(1, 20, 162446.0185265718, 65.28911664703388, 1786857.8926660626), ...
另请参阅相关C++方法的文档
pagmo::de::get_log()。
- class pygmo.sea(gen=1, seed=random)#
(N+1)-ES 简单进化算法。
- Parameters
- Raises
OverflowError – 如果 gen 或 seed 为负数或大于实现定义的值
未指定 – 任何由C++和Python之间的交互失败引发的异常 （例如，类型转换错误，函数签名不匹配等）
另请参阅C++类
pagmo::sea的文档。- get_log()#
返回一个日志，包含上次调用
evolve()时记录的相关参数并打印到屏幕上。 日志的频率取决于详细程度参数（默认情况下不记录日志），可以通过在构造的algorithm上调用方法set_verbosity()来设置。 详细程度大于1时，每次详细程度适应度评估都会生成一个日志条目。 详细程度等于1时，每次适应度改进时都会生成一个日志条目。- Returns
at each logged epoch, the values
Gen,Fevals,Best,Improvement,Mutations- Return type
示例
>>> from pygmo import * >>> algo = algorithm(sea(500)) >>> algo.set_verbosity(50) >>> prob = problem(schwefel(dim = 20)) >>> pop = population(prob, 20) >>> pop = algo.evolve(pop) Gen: Fevals: Best: Improvement: Mutations: 1 1 6363.44 2890.49 2 1001 1001 1039.92 -562.407 3 2001 2001 358.966 -632.6 2 3001 3001 106.08 -995.927 3 4001 4001 83.391 -266.8 1 5001 5001 62.4994 -1018.38 3 6001 6001 39.2851 -732.695 2 7001 7001 37.2185 -518.847 1 8001 8001 20.9452 -450.75 1 9001 9001 17.9193 -270.679 1 >>> uda = algo.extract(sea) >>> uda.get_log() [(1, 1, 6363.442036625835, 2890.4854414320716, 2), (1001, 1001, ...
另请参阅相关C++方法的文档
pagmo::sea::get_log()。
- class pygmo.sga(gen=1, cr=.90, eta_c=1., m=0.02, param_m=1., param_s=2, crossover='exponential', mutation='polynomial', selection='tournament', seed=random)#
一个简单的遗传算法
版本2.2中的新功能。
大约在与进化策略（见
sea）研究的同一时期，由约翰·霍兰德领导，后来由他的学生大卫·戈德伯格领导的另一个小组引入并研究了一种称为“遗传算法”的算法框架，该框架本质上利用了相同的想法，但也引入了交叉作为遗传操作符。这导致了数十年的混淆和讨论，关于什么是进化策略，什么是遗传算法，以及交叉是否是一个有用的操作符，或者仅使用变异的算法是否更受青睐。在pygmo中，我们提供了一个相当经典的遗传算法实现，让用户可以在选定的交叉类型、选择方案和变异类型之间进行选择。
我们版本的伪代码如下：
> Start from a population (pop) of dimension N > while i < gen > > Selection: create a new population (pop2) with N individuals selected from pop (with repetition allowed) > > Crossover: create a new population (pop3) with N individuals obtained applying crossover to pop2 > > Mutation: create a new population (pop4) with N individuals obtained applying mutation to pop3 > > Evaluate all new chromosomes in pop4 > > Reinsertion: set pop to contain the best N individuals taken from pop and pop4
pygmo遗传算法的各个模块如下所示：
选择：提供了两种选择方法：
tournament和truncated。Tournament选择通过在一个大小为 param_s 的随机组中选择每个后代作为具有最小适应度的个体来工作。而truncated选择则是通过在整个种群中反复选择最好的 param_s 条染色体来工作。 我们故意没有实现流行的轮盘赌选择，因为我们认为这种系统对适应度缩放高度敏感，因此不太具有普遍性。交叉：提供了四种不同的交叉方案：
single、exponential、binomial、sbx。single单点交叉，通过在父染色体中随机选择一个点，并以概率 cr 在此后插入伴侣染色体来工作。exponential指数交叉来自差分进化算法， 在 pygmo 中实现为de。它基本上在父染色体中随机选择一个点，并在每个连续的基因中以概率 cr 插入伴侣值，直到停止为止。二项式交叉 以概率 cr 插入伴侣的每个基因。模拟二进制交叉（称为sbx）来自 NSGA-II 算法，在 pygmo 中实现为nsga2，并使用一个称为 分布指数 eta_c 的额外参数。变异：提供了三种不同的变异方案：
uniform、gaussian和polynomial。均匀变异简单地从边界内随机采样。高斯变异使用正态分布在每个基因周围采样，标准差与param_m和边界宽度成比例。最后一种方案是Deb的polynomial变异。重新插入：我们提供的唯一重新插入策略是我们所谓的纯精英主义。每一代之后，所有的父母和孩子都被放入同一个池中，只有最好的才会被传递到下一代。
- Parameters
gen (
int) – 代数数量。cr (
float) – 交叉概率。eta_c (
float) –sbx交叉的分布指数。如果选择了其他类型的交叉，此参数将不起作用。m (
float) – 变异概率。param_m (
float) – 分布指数（多项式变异），高斯宽度（高斯变异）或不活跃（均匀变异）param_s (
float) – 在“截断”选择中使用的最佳个体数量，或在tournament选择中的锦标赛大小。crossover (
str) – 交叉策略。可以是exponential、binomial、single或sbx之一mutation (
str) – 变异策略。可以是gaussian、polynomial或uniform之一。selection (
str) – 选择策略。可以是tournament或 “truncated” 之一。seed (
int) – 内部随机数生成器使用的种子
- Raises
OverflowError – 如果 gen 或 seed 为负数或大于实现定义的值
ValueError – 如果 cr 不在 [0,1] 范围内，如果 eta_c 不在 [1,100] 范围内，如果 m 不在 [0,1] 范围内，输入 mutation 不是
gaussian、uniform或polynomial之一，如果 selection 不是 “roulette”、“truncated” 或 crossover 不是exponential、binomial、sbx、single之一，如果 param_m 不在 [0,1] 范围内且 mutation 不是polynomial，如果 mutation 不在 [1,100] 范围内且 mutation 是polynomial未指定 – 任何由C++和Python之间的交互失败引发的异常 （例如，类型转换错误，函数签名不匹配等）
另请参阅C++类
pagmo::sga的文档。- get_log()#
返回一个日志，包含上次调用
evolve()时记录的相关参数并打印到屏幕上。 日志的频率取决于详细程度参数（默认情况下不记录日志），可以通过在构造的algorithm上调用方法set_verbosity()来设置。 详细程度大于1时，每次详细程度适应度评估将生成一个日志条目。 详细程度等于1时，每次适应度改进时将生成一个日志条目。- Returns
在每个记录的周期，值
Gen,Fevals,Best,ImprovementGen(int), 世代.Fevals(int), 进行的函数评估次数.Best(float), 迄今为止找到的最佳适应度函数.Improvement(float), 上一世代所做的改进.- Return type
示例
>>> from pygmo import * >>> algo = algorithm(sga(gen = 500)) >>> algo.set_verbosity(50) >>> prob = problem(schwefel(dim = 20)) >>> pop = population(prob, 20) >>> pop = algo.evolve(pop) Gen: Fevals: Best: Improvement: Mutations: 1 1 6363.44 2890.49 2 1001 1001 1039.92 -562.407 3 2001 2001 358.966 -632.6 2 3001 3001 106.08 -995.927 3 4001 4001 83.391 -266.8 1 5001 5001 62.4994 -1018.38 3 6001 6001 39.2851 -732.695 2 7001 7001 37.2185 -518.847 1 8001 8001 20.9452 -450.75 1 9001 9001 17.9193 -270.679 1 >>> uda = algo.extract(sea) >>> uda.get_log() [(1, 1, 6363.442036625835, 2890.4854414320716, 2), (1001, 1001, ...
另请参阅相关C++方法的文档
pagmo::sga::get_log()。
- class pygmo.sade(gen=1, variant=2, variant_adptv=1, ftol=1e-6, xtol=1e-6, memory=False, seed=random)#
自适应差分进化。
- Parameters
- Raises
OverflowError – 如果 gen、variant、variant_adptv 或 seed 为负数或大于实现定义的值
ValueError – 如果 variant 不在 [1,18] 范围内或 variant_adptv 不在 [0,1] 范围内
以下变体（突变变体）可用于创建新的候选个体：
1 - 最佳/1/指数
2 - 随机/1/指数
3 - 随机到最佳/1/指数
4 - 最佳/2/指数
5 - 随机数/2/指数
6 - 最佳/1/二进制
7 - 随机/1/二进制
8 - 随机到最佳/1/二进制
9 - 最佳/2/二进制
10 - 随机/2/二进制
11 - 随机/3/指数
12 - rand/3/bin
13 - 最佳/3/指数
14 - 最佳/3/二进制
15 - 随机到当前/2/指数
16 - 随机到当前/2/二进制
17 - 随机到最佳和当前/2/指数
18 - 随机到最佳和当前/2/二进制
以下适应方案可用：
1 - jDE
2 - iDE
另请参阅C++类
pagmo::sade的文档。- get_log()#
返回一个包含上次调用
evolve()期间记录的相关参数的日志。日志频率取决于详细程度参数（默认情况下不记录任何内容），可以通过在构造了sade的algorithm上调用方法set_verbosity()来设置。详细程度为N意味着每N代记录一行日志。- Returns
at each logged epoch, the values
Gen,Fevals,Best,F,CR,dx,df, where:Gen(int), generation numberFevals(int), number of functions evaluation madeBest(float), the best fitness function currently in the populationF(float), the value of the adapted paramter F used to create the best so farCR(float), the value of the adapted paramter CR used to create the best so fardx(float), the norm of the distance to the population mean of the mutant vectorsdf(float), the population flatness evaluated as the distance between the fitness of the best and of the worst individual
- Return type
示例
>>> from pygmo import * >>> algo = algorithm(sade(gen = 500)) >>> algo.set_verbosity(100) >>> prob = problems.rosenbrock(10) >>> pop = population(prob, 20) >>> pop = algo.evolve(pop) Gen: Fevals: Best: F: CR: dx: df: 1 20 297060 0.690031 0.294769 44.1494 2.30584e+06 101 2020 97.4258 0.58354 0.591527 13.3115 441.545 201 4020 8.79247 0.6678 0.53148 17.8822 121.676 301 6020 6.84774 0.494549 0.98105 12.2781 40.9626 401 8020 4.7861 0.428741 0.743813 12.2938 39.7791 Exit condition -- generations = 500 >>> uda = algo.extract(sade) >>> uda.get_log() [(1, 20, 297059.6296130389, 0.690031071850855, 0.29476914701127666, 44.14940516578547, 2305836.7422693395), ...
另请参阅相关C++方法的文档
pagmo::sade::get_log()。
- class pygmo.de1220(gen=1, allowed_variants=[2, 3, 7, 10, 13, 14, 15, 16], variant_adptv=1, ftol=1e-6, xtol=1e-6, memory=False, seed=random)#
自适应差分进化，pygmo风格（pDE）。 变异变体的适应已添加到
sade- Parameters
- Raises
OverflowError – 如果 gen、variant、variant_adptv 或 seed 为负数或大于实现定义的值
ValueError – 如果variant_adptv中的每个id不在[1,18]范围内，或者variant_adptv不在[0,1]范围内
以下变体（突变变体）可以放入 allowed_variants 中：
1 - 最佳/1/指数
2 - 随机/1/指数
3 - 随机到最佳/1/指数
4 - 最佳/2/指数
5 - 随机数/2/指数
6 - 最佳/1/二进制
7 - 随机/1/二进制
8 - 随机到最佳/1/二进制
9 - 最佳/2/二进制
10 - 随机/2/二进制
11 - 随机/3/指数
12 - rand/3/bin
13 - 最佳/3/指数
14 - 最佳/3/二进制
15 - 随机到当前/2/指数
16 - 随机到当前/2/二进制
17 - 随机到最佳和当前/2/指数
18 - 随机到最佳和当前/2/二进制
以下是对参数F和CR的适应方案：
1 - jDE
2 - iDE
另请参阅C++类
pagmo::de1220的文档。- get_log()#
返回一个包含上次调用
evolve()期间记录的相关参数的日志。日志频率取决于详细程度参数（默认情况下不记录任何内容），可以通过在构造algorithm时调用set_verbosity()方法来设置，该算法使用de1220构建。详细程度为N意味着每N代记录一行日志。- Returns
at each logged epoch, the values
Gen,Fevals,Best,F,CR,Variant,dx,df, where:Gen(int), generation numberFevals(int), number of functions evaluation madeBest(float), the best fitness function currently in the populationF(float), the value of the adapted paramter F used to create the best so farCR(float), the value of the adapted paramter CR used to create the best so farVariant(int), the mutation variant used to create the best so fardx(float), the norm of the distance to the population mean of the mutant vectorsdf(float), the population flatness evaluated as the distance between the fitness of the best and of the worst individual
- Return type
示例
>>> from pygmo import * >>> algo = algorithm(de1220(gen = 500)) >>> algo.set_verbosity(100) >>> prob = problem(rosenbrock(10)) >>> pop = population(prob, 20) >>> pop = algo.evolve(pop) Gen: Fevals: Best: F: CR: Variant: dx: df: 1 20 285653 0.55135 0.441551 16 43.9719 2.02379e+06 101 2020 12.2721 0.127285 0.0792493 14 3.22986 106.764 201 4020 5.72927 0.148337 0.777806 14 2.72177 4.10793 301 6020 4.85084 0.12193 0.996191 3 2.95555 3.85027 401 8020 4.20638 0.235997 0.996259 3 3.60338 4.49432 Exit condition -- generations = 500 >>> uda = algo.extract(de1220) >>> uda.get_log() [(1, 20, 285652.7928977573, 0.551350234239449, 0.4415510963067054, 16, 43.97185788345982, 2023791.5123259544), ...
另请参阅相关C++方法的文档
pagmo::de1220::get_log()。
- class pygmo.cmaes(gen=1, cc=- 1, cs=- 1, c1=- 1, cmu=- 1, sigma0=0.5, ftol=1e-6, xtol=1e-6, memory=False, force_bounds=False, seed=random)#
协方差矩阵进化策略（CMA-ES）。
- Parameters
gen (
int) – 代数数量cc (
float) – 进化路径的向后时间范围（默认情况下自动分配）cs (
float) – 在指标为零的情况下，部分弥补了小方差损失（默认情况下会自动分配）c1 (
float) – 协方差矩阵的秩一更新的学习率（默认情况下自动分配）cmu (
float) – 用于协方差矩阵的rank-mu更新的学习率（默认情况下会自动分配）sigma0 (
float) – 初始步长ftol (
float) – 停止条件基于x的容差xtol (
float) – 停止标准基于f的容差memory (
bool) – 当为true时，适配的参数在连续调用evolve方法之间不会被重置force_bounds (
bool) – 当为true时，强制实施边界限制。适应度函数永远不会在边界之外被调用，但协方差矩阵适应机制会变差seed (
int) – 内部随机数生成器使用的种子（默认是随机的）
- Raises
OverflowError – 如果 gen 是负数或大于实现定义的值
ValueError – 如果 cc, cs, c1, cmu 不在 [0,1] 或 -1 范围内
另请参阅C++类
pagmo::cmaes的文档。- get_log()#
返回一个日志，包含上次调用
evolve()期间记录的相关参数。日志频率取决于详细程度参数（默认情况下不记录任何内容），可以通过在构造的algorithm上调用方法set_verbosity()来设置，该算法使用cmaes构建。详细程度为N意味着每N代记录一行日志。- Returns
at each logged epoch, the values
Gen,Fevals,Best,dx,df,sigma, where:Gen(int), generation numberFevals(int), number of functions evaluation madeBest(float), the best fitness function currently in the populationdx(float), the norm of the distance to the population mean of the mutant vectorsdf(float), the population flatness evaluated as the distance between the fitness of the best and of the worst individualsigma(float), the current step-size
- Return type
示例
>>> from pygmo import * >>> algo = algorithm(cmaes(gen = 500)) >>> algo.set_verbosity(100) >>> prob = problem(rosenbrock(10)) >>> pop = population(prob, 20) >>> pop = algo.evolve(pop) Gen: Fevals: Best: dx: df: sigma: 1 0 173924 33.6872 3.06519e+06 0.5 101 2000 92.9612 0.583942 156.921 0.0382078 201 4000 8.79819 0.117574 5.101 0.0228353 301 6000 4.81377 0.0698366 1.34637 0.0297664 401 8000 1.04445 0.0568541 0.514459 0.0649836 Exit condition -- generations = 500 >>> uda = algo.extract(cmaes) >>> uda.get_log() [(1, 0, 173924.2840042722, 33.68717961390855, 3065192.3843070837, 0.5), ...
另请参阅相关C++方法的文档
pagmo::cmaes::get_log()。
- class pygmo.moead(gen=1, weight_generation='grid', decomposition='tchebycheff', neighbours=20, CR=1, F=0.5, eta_m=20, realb=0.9, limit=2, preserve_diversity=true, seed=random)#
基于分解的多目标进化算法（DE变体）
- Parameters
gen (
int) – 代数数量weight_generation (
str) – 用于生成权重的方法，可选“grid”、“low discrepancy”或“random”分解 (
str) – 用于分解目标的方法，其中之一是“tchebycheff”、“weighted”或“bi”neighbours (
int) – 权重邻域的大小CR (
float) – 差分进化算子中的交叉参数F (
float) – 差分进化算子的参数eta_m (
float) – 多项式变异使用的分布指数realb (
float) – 每代考虑邻域而非整个种群的概率（仅在 preserve_diversity 为 true 时有效）limit (
int) – 重新插入种群中的最大副本数（仅在 m_preserve_diversity 为 true 时有效）preserve_diversity (
bool) – 当为true时激活多样性保护机制seed (
int) – 内部随机数生成器使用的种子（默认是随机的）
- Raises
OverflowError – 如果 gen, neighbours, seed 或 limit 为负数或大于实现定义的值
ValueError – 如果 decomposition 不是 ‘tchebycheff’, ‘weighted’ 或 ‘bi’ 之一， weight_generation 不是 ‘random’, ‘low discrepancy’ 或 ‘grid’ 之一， CR 或 F 或 realb 不在 [0.,1.] 范围内，或者 eta_m 为负数，如果 neighbours 不大于等于 2
另请参阅C++类
pagmo::moead的文档。- get_log()#
返回一个包含上次调用
evolve()期间记录的相关参数的日志。日志频率取决于详细程度参数（默认情况下不记录任何内容），可以通过在构造的algorithm上调用方法set_verbosity()来设置，该算法使用moead构建。详细程度为N意味着每N代记录一行日志。- Returns
在每个记录的时期，值
Gen,Fevals,ADR,ideal_point，其中：- Return type
示例
>>> from pygmo import * >>> algo = algorithm(moead(gen=500)) >>> algo.set_verbosity(100) >>> prob = problem(zdt()) >>> pop = population(prob, 40) >>> pop = algo.evolve(pop) Gen: Fevals: ADF: ideal1: ideal2: 1 0 32.5747 0.00190532 2.65685 101 4000 5.67751 2.56736e-09 0.468789 201 8000 5.38297 2.56736e-09 0.0855025 301 12000 5.05509 9.76581e-10 0.0574796 401 16000 5.13126 9.76581e-10 0.0242256 >>> uda = algo.extract(moead) >>> uda.get_log() [(1, 0, 32.574745630075874, array([ 1.90532430e-03, 2.65684834e+00])), ...
另请参阅相关C++方法的文档
pagmo::moead::get_log()。
- class pygmo.moead_gen(gen=1, weight_generation='grid', decomposition='tchebycheff', neighbours=20, CR=1, F=0.5, eta_m=20, realb=0.9, limit=2, preserve_diversity=true, seed=random)#
基于分解的多目标进化算法（DE变体）
- Parameters
gen (
int) – 代数数量weight_generation (
str) – 用于生成权重的方法，可选“grid”、“low discrepancy”或“random”分解 (
str) – 用于分解目标的方法，其中之一是“tchebycheff”、“weighted”或“bi”neighbours (
int) – 权重邻域的大小CR (
float) – 差分进化算子中的交叉参数F (
float) – 差分进化算子的参数eta_m (
float) – 多项式变异使用的分布指数realb (
float) – 每代考虑邻域而非整个种群的概率（仅在 preserve_diversity 为 true 时有效）limit (
int) – 重新插入种群中的最大副本数（仅在 m_preserve_diversity 为 true 时有效）preserve_diversity (
bool) – 当为true时激活多样性保护机制seed (
int) – 内部随机数生成器使用的种子（默认是随机的）
- Raises
OverflowError – 如果 gen, neighbours, seed 或 limit 为负数或大于实现定义的值
ValueError – 如果 decomposition 不是 ‘tchebycheff’, ‘weighted’ 或 ‘bi’ 之一， weight_generation 不是 ‘random’, ‘low discrepancy’ 或 ‘grid’ 之一， CR 或 F 或 realb 不在 [0.,1.] 范围内，或者 eta_m 为负数，如果 neighbours 不大于等于 2
另请参阅C++类
pagmo::moead_gen的文档。- get_log()#
返回一个包含上次调用
evolve()期间记录的相关参数的日志。日志频率取决于详细程度参数（默认情况下不记录任何内容），可以通过在构造的algorithm上调用方法set_verbosity()来设置，该算法使用moead_gen构建。详细程度为N意味着每N代记录一行日志。- Returns
在每个记录的时期，值
Gen,Fevals,ADR,ideal_point, 其中：- Return type
示例
>>> from pygmo import * >>> algo = algorithm(moead_gen(gen=500)) >>> algo.set_verbosity(100) >>> prob = problem(zdt()) >>> pop = population(prob, 40) >>> pop = algo.evolve(pop) Gen: Fevals: ADF: ideal1: ideal2: 1 0 32.5747 0.00190532 2.65685 101 4000 5.67751 2.56736e-09 0.468789 201 8000 5.38297 2.56736e-09 0.0855025 301 12000 5.05509 9.76581e-10 0.0574796 401 16000 5.13126 9.76581e-10 0.0242256 >>> uda = algo.extract(moead_gen) >>> uda.get_log() [(1, 0, 32.574745630075874, array([ 1.90532430e-03, 2.65684834e+00])), ...
另请参阅相关C++方法的文档
pagmo::moead_gen::get_log()。
- class pygmo.compass_search(max_fevals=1, start_range=.1, stop_range=.01, reduction_coeff=.5)#
指南针搜索
- Parameters
- Raises
OverflowError – 如果 max_fevals 为负数或大于实现定义的值
ValueError – 如果 start_range 不在 (0, 1] 范围内，如果 stop_range 不在 (start_range, 1] 范围内，或者如果 reduction_coeff 不在 (0,1) 范围内
另请参阅C++类
pagmo::compass_search的文档。- get_log()#
返回一个日志，包含上次调用
evolve()时记录的相关参数并打印到屏幕上。日志频率取决于详细程度参数（默认情况下不记录任何内容），可以通过在构造的algorithm上调用方法set_verbosity()来设置，该算法使用compass_search构建。详细程度大于0意味着每次适应度改进或搜索范围变化时都会记录一行日志。- Returns
在每个记录的时期，值``Fevals``,
Best,Range，其中：- Return type
示例
>>> from pygmo import * >>> algo = algorithm(compass_search(max_fevals = 500)) >>> algo.set_verbosity(1) >>> prob = problem(hock_schittkowski_71()) >>> pop = population(prob, 1) >>> pop = algo.evolve(pop) Fevals: Best: Violated: Viol. Norm: Range: 4 110.785 1 2.40583 0.5 12 110.785 1 2.40583 0.25 20 110.785 1 2.40583 0.125 22 91.0454 1 1.01855 0.125 25 96.2795 1 0.229446 0.125 33 96.2795 1 0.229446 0.0625 41 96.2795 1 0.229446 0.03125 45 94.971 1 0.127929 0.03125 53 94.971 1 0.127929 0.015625 56 95.6252 1 0.0458521 0.015625 64 95.6252 1 0.0458521 0.0078125 68 95.2981 1 0.0410151 0.0078125 76 95.2981 1 0.0410151 0.00390625 79 95.4617 1 0.00117433 0.00390625 87 95.4617 1 0.00117433 0.00195312 95 95.4617 1 0.00117433 0.000976562 103 95.4617 1 0.00117433 0.000488281 111 95.4617 1 0.00117433 0.000244141 115 95.4515 0 0 0.000244141 123 95.4515 0 0 0.00012207 131 95.4515 0 0 6.10352e-05 139 95.4515 0 0 3.05176e-05 143 95.4502 0 0 3.05176e-05 151 95.4502 0 0 1.52588e-05 159 95.4502 0 0 7.62939e-06 Exit condition -- range: 7.62939e-06 <= 1e-05 >>> uda = algo.extract(compass_search) >>> uda.get_log() [(4, 110.785345345, 1, 2.405833534534, 0.5), (12, 110.785345345, 1, 2.405833534534, 0.25) ...
另请参阅相关C++方法的文档
pagmo::compass_search::get_log()。
- property replacement#
个体替换策略。
此属性表示在
evolve()方法中用于选择将被优化个体替换的个体的策略。该属性可以是字符串或整数。如果属性是字符串，它必须是
"best"、"worst"和"random"之一："best"将选择种群中的最佳个体，"worst"将选择种群中最差的个体，"random"将在种群中随机选择一个个体。
set_random_sr_seed()可用于为"random"策略使用的随机数生成器设置种子。如果属性是整数，它表示将被优化个体替换的个体在种群中的索引。
- Returns
个人替换策略或索引
- Return type
- Raises
OverflowError – 如果属性被设置为负数或过大的整数
ValueError – 如果属性设置为无效字符串
TypeError – 如果属性设置为无效类型的值
未指定 – 任何由C++和Python之间的失败引发的异常（例如，类型转换错误、函数签名不匹配等）。
- property selection#
个体选择策略。
此属性表示在
evolve()方法中用于选择将被优化的个体的策略。该属性可以是字符串或整数。如果属性是字符串，它必须是
"best"、"worst"和"random"之一："best"将选择种群中的最佳个体，"worst"将选择种群中最差的个体，"random"将在种群中随机选择一个个体。
set_random_sr_seed()可用于为"random"策略使用的随机数生成器设置种子。如果属性是整数，它表示被选中进行优化的个体在种群中的索引。
- Returns
个体选择策略或索引
- Return type
- Raises
OverflowError – 如果属性设置为负数或过大的整数
ValueError – 如果属性设置为无效字符串
TypeError – 如果属性设置为无效类型的值
未指定 – 任何由C++和Python之间的失败引发的异常（例如，类型转换错误、函数签名不匹配等）。
- set_random_sr_seed(seed)#
为
"random"选择/替换策略设置种子。- Parameters
seed (
int) – 用于播种随机数生成器的值，该生成器由"random"选举/替换策略使用（参见selection和replacement）- Raises
OverflowError – 如果属性设置为负数或过大的整数
未指定 – 任何由C++和Python之间的失败引发的异常（例如，类型转换错误、函数签名不匹配等）。
- class pygmo.simulated_annealing(Ts=10., Tf=.1, n_T_adj=10, n_range_adj=10, bin_size=10, start_range=1., seed=random)#
模拟退火（Corana版本）
- Parameters
- Raises
OverflowError – 如果 n_T_adj, n_range_adj 或 bin_size 为负数或大于实现定义的值
ValueError – 如果 Ts 不在 (0, inf) 范围内，如果 Tf 不在 (0, inf) 范围内，如果 Tf > Ts 或者如果 start_range 不在 (0,1] 范围内
ValueError – 如果 n_T_adj 不是严格正数，或者如果 n_range_adj 不是严格正数
另请参阅C++类
pagmo::simulated_annealing的文档。- get_log()#
返回一个日志，包含上次调用
evolve()期间记录的相关参数并打印到屏幕上。 日志频率取决于详细程度参数（默认情况下不记录任何内容），可以通过在构造的algorithm上调用方法set_verbosity()来设置，该算法使用simulated_annealing构建。详细程度大于0将产生一个日志，每次详细程度适应度评估都会有一个条目。- Returns
at each logged epoch, the values
Fevals,Best,Current,Mean range,Temperature, where:Fevals(int), number of functions evaluation madeBest(float), the best fitness function found so farCurrent(float), last fitness sampledMean range(float), the mean search range across the decision vector components (relative to the box bounds width)Temperature(float), the current temperature
- Return type
示例
>>> from pygmo import * >>> algo = algorithm(simulated_annealing(Ts=10., Tf=1e-5, n_T_adj = 100)) >>> algo.set_verbosity(5000) >>> prob = problem(rosenbrock(dim = 10)) >>> pop = population(prob, 1) >>> pop = algo.evolve(pop) Fevals: Best: Current: Mean range: Temperature: 57 5937 5937 0.48 10 10033 9.50937 28.6775 0.0325519 2.51189 15033 7.87389 14.3951 0.0131132 1.25893 20033 7.87389 8.68616 0.0120491 0.630957 25033 2.90084 4.43344 0.00676893 0.316228 30033 0.963616 1.36471 0.00355931 0.158489 35033 0.265868 0.63457 0.00202753 0.0794328 40033 0.13894 0.383283 0.00172611 0.0398107 45033 0.108051 0.169876 0.000870499 0.0199526 50033 0.0391731 0.0895308 0.00084195 0.01 55033 0.0217027 0.0303561 0.000596116 0.00501187 60033 0.00670073 0.00914824 0.000342754 0.00251189 65033 0.0012298 0.00791511 0.000275182 0.00125893 70033 0.00112816 0.00396297 0.000192117 0.000630957 75033 0.000183055 0.00139717 0.000135137 0.000316228 80033 0.000174868 0.00192479 0.000109781 0.000158489 85033 7.83e-05 0.000494225 8.20723e-05 7.94328e-05 90033 5.35153e-05 0.000120148 5.76009e-05 3.98107e-05 95033 5.35153e-05 9.10958e-05 3.18624e-05 1.99526e-05 99933 2.34849e-05 8.72206e-05 2.59215e-05 1.14815e-05 >>> uda = algo.extract(simulated_annealing) >>> uda.get_log() [(57, 5936.999957947842, 5936.999957947842, 0.47999999999999987, 10.0), (10033, ...
另请参阅相关C++方法的文档
pagmo::simulated_annealing::get_log()。
- property replacement#
个体替换策略。
此属性表示在
evolve()方法中用于选择将被优化个体替换的个体的策略。该属性可以是字符串或整数。如果属性是字符串，它必须是
"best"、"worst"和"random"之一："best"将选择种群中的最佳个体，"worst"将选择种群中最差的个体，"random"将在种群中随机选择一个个体。
set_random_sr_seed()可用于为"random"策略使用的随机数生成器设置种子。如果属性是整数，它表示将被优化个体替换的个体在种群中的索引。
- Returns
个人替换策略或索引
- Return type
- Raises
OverflowError – 如果属性设置为负数或过大的整数
ValueError – 如果属性设置为无效字符串
TypeError – 如果属性设置为无效类型的值
未指定 – 任何由C++和Python之间的失败引发的异常（例如，类型转换错误、函数签名不匹配等）。
- property selection#
个体选择策略。
此属性表示在
evolve()方法中用于选择将被优化的个体的策略。该属性可以是字符串或整数。如果属性是字符串，它必须是
"best"、"worst"和"random"之一："best"将选择种群中的最佳个体，"worst"将选择种群中最差的个体，"random"将在种群中随机选择一个个体。
set_random_sr_seed()可用于为"random"策略使用的随机数生成器设置种子。如果属性是整数，它表示被选中进行优化的个体在种群中的索引。
- Returns
个体选择策略或索引
- Return type
- Raises
OverflowError – 如果属性设置为负数或过大的整数
ValueError – 如果属性设置为无效字符串
TypeError – 如果属性设置为无效类型的值
未指定 – 任何由C++和Python之间的失败引发的异常（例如，类型转换错误、函数签名不匹配等）。
- set_random_sr_seed(seed)#
为
"random"选择/替换策略设置种子。- Parameters
seed (
int) – 用于播种随机数生成器的值，该生成器由"random"选举/替换策略使用（参见selection和replacement）- Raises
OverflowError – 如果属性设置为负数或过大的整数
未指定 – 任何由C++和Python之间的失败引发的异常（例如，类型转换错误、函数签名不匹配等）。
- class pygmo.pso(gen=1, omega=0.7298, eta1=2.05, eta2=2.05, max_vel=0.5, variant=5, neighb_type=2, neighb_param=4, memory=False, seed=random)#
粒子群优化
- Parameters
gen (
int) – 代数数量omega (
float) – 惯性权重（或收缩因子）eta1 (
float) – 社交组件eta2 (
float) – 认知组件max_vel (
float) – 允许的最大粒子速度（相对于边界宽度进行归一化）variant (
int) – 算法变体neighb_type (
int) – 群体拓扑（定义每个粒子的邻居）neighb_param (
int) – 拓扑参数（定义要考虑多少个邻居）memory (
bool) – 当为true时，速度在连续调用evolve方法之间不会被重置seed (
int) – 内部随机数生成器使用的种子（默认是随机的）
- Raises
OverflowError – 如果 gen 或 seed 为负数或大于实现定义的值
ValueError – 如果 omega 不在 [0,1] 区间内，如果 eta1, eta2 不在 [0,4] 区间内，如果 max_vel 不在 ]0,1] 区间内
ValueError – variant 不是 1 到 6 中的一个，如果 neighb_type 不是 1 到 4 中的一个，或者如果 neighb_param 为零
可以通过variant参数选择以下变体：
1 - 规范（带惯性权重）
2 - 相同的社会和认知随机性。
3 - 所有组件使用相同的随机数
4 - 只有一个随机数。
5 - 规范（带有收缩因子）
6 - 完全知情 (FIPS)
以下拓扑由neighb_type选择：
1 - 全局最优
2 - 局部最优
3 - 冯·诺伊曼
4 - 自适应随机
拓扑结构（与拓扑参数一起）决定了在计算速度更新的社会组件时需要考虑哪些粒子。
- get_log()#
返回一个日志，包含上次调用
evolve()时记录的相关参数并打印到屏幕上。日志频率取决于详细程度参数（默认情况下不记录任何内容），可以通过在构造的algorithm上调用方法set_verbosity()来设置，该算法使用pso构建。详细程度为N意味着每N代记录一行日志。- Returns
at each logged epoch, the values
Gen,Fevals,gbest,Mean Vel.,Mean lbest,Avg. Dist., where:Gen(int), generation numberFevals(int), number of functions evaluation madegbest(float), the best fitness function found so far by the the swarmMean Vel.(float), the average particle velocity (normalized)Mean lbest(float), the average fitness of the current particle locationsAvg. Dist.(float), the average distance between particles (normalized)
- Return type
示例
>>> from pygmo import * >>> algo = algorithm(pso(gen = 500)) >>> algo.set_verbosity(50) >>> prob = problem(rosenbrock(10)) >>> pop = population(prob, 20) >>> pop = algo.evolve(pop) Gen: Fevals: gbest: Mean Vel.: Mean lbest: Avg. Dist.: 1 40 72473.3 0.173892 677427 0.281744 51 1040 135.867 0.0183806 748.001 0.065826 101 2040 12.6726 0.00291046 84.9531 0.0339452 151 3040 8.4405 0.000852588 33.5161 0.0191379 201 4040 7.56943 0.000778264 28.213 0.00789202 251 5040 6.8089 0.00435521 22.7988 0.00107112 301 6040 6.3692 0.000289725 17.3763 0.00325571 351 7040 6.09414 0.000187343 16.8875 0.00172307 401 8040 5.78415 0.000524536 16.5073 0.00234197 451 9040 5.4662 0.00018305 16.2339 0.000958182 >>> uda = algo.extract(pso) >>> uda.get_log() [(1,40,72473.32713790605,0.1738915144248373,677427.3504996448,0.2817443174278134), (51,1040,...
另请参阅相关C++方法的文档
pagmo::pso::get_log()。
- class pygmo.pso_gen(gen=1, omega=0.7298, eta1=2.05, eta2=2.05, max_vel=0.5, variant=5, neighb_type=2, neighb_param=4, memory=False, seed=random)#
粒子群优化（generational）与
pso相同，但在计算新粒子位置之前会更新每个粒子的速度（考虑到所有更新的粒子速度）。因此，每一代中的每个粒子都在相同的种子下进行评估，而不是像标准PSO那样一次评估单个粒子。因此，generational PSO算法适用于随机优化问题。- Parameters
gen (
int) – 代数数量omega (
float) – 惯性权重（或收缩因子）eta1 (
float) – 社交组件eta2 (
float) – 认知组件max_vel (
float) – 允许的最大粒子速度（相对于边界宽度进行归一化）variant (
int) – 算法变体neighb_type (
int) – 群体拓扑（定义每个粒子的邻居）neighb_param (
int) – 拓扑参数（定义要考虑多少个邻居）memory (
bool) – 当为true时，速度在连续调用evolve方法之间不会被重置seed (
int) – 内部随机数生成器使用的种子（默认是随机的）
- Raises
OverflowError – 如果 gen 或 seed 为负数或大于实现定义的值
ValueError – 如果 omega 不在 [0,1] 区间内，如果 eta1, eta2 不在 [0,1] 区间内，如果 max_vel 不在 ]0,1] 区间内
ValueError – variant 不是 1 到 6 中的一个，如果 neighb_type 不是 1 到 4 中的一个，或者如果 neighb_param 为零
可以通过variant参数选择以下变体：
1 - 规范（带惯性权重）
2 - 相同的社会和认知随机性。
3 - 所有组件使用相同的随机数
4 - 只有一个随机数。
5 - 规范（带有收缩因子）
6 - 完全知情 (FIPS)
以下拓扑由neighb_type选择：
1 - 全局最优
2 - 局部最优
3 - 冯·诺伊曼
4 - 自适应随机
拓扑结构（与拓扑参数一起）决定了在计算速度更新的社会组件时需要考虑哪些粒子。
- get_log()#
返回一个日志，包含上次调用
evolve()期间记录的相关参数并打印到屏幕上。日志频率取决于详细程度参数（默认情况下不记录任何内容），可以通过在构造的algorithm上调用方法set_verbosity()来设置，该算法使用pso构建。详细程度为N意味着每N代记录一行日志。- Returns
at each logged epoch, the values
Gen,Fevals,gbest,Mean Vel.,Mean lbest,Avg. Dist., where:Gen(int), generation numberFevals(int), number of functions evaluation madegbest(float), the best fitness function found so far by the the swarmMean Vel.(float), the average particle velocity (normalized)Mean lbest(float), the average fitness of the current particle locationsAvg. Dist.(float), the average distance between particles (normalized)
- Return type
示例
>>> from pygmo import * >>> algo = algorithm(pso(gen = 500)) >>> algo.set_verbosity(50) >>> prob = problem(rosenbrock(10)) >>> pop = population(prob, 20) >>> pop = algo.evolve(pop) Gen: Fevals: gbest: Mean Vel.: Mean lbest: Avg. Dist.: 1 40 72473.3 0.173892 677427 0.281744 51 1040 135.867 0.0183806 748.001 0.065826 101 2040 12.6726 0.00291046 84.9531 0.0339452 151 3040 8.4405 0.000852588 33.5161 0.0191379 201 4040 7.56943 0.000778264 28.213 0.00789202 251 5040 6.8089 0.00435521 22.7988 0.00107112 301 6040 6.3692 0.000289725 17.3763 0.00325571 351 7040 6.09414 0.000187343 16.8875 0.00172307 401 8040 5.78415 0.000524536 16.5073 0.00234197 451 9040 5.4662 0.00018305 16.2339 0.000958182 >>> uda = algo.extract(pso) >>> uda.get_log() [(1,40,72473.32713790605,0.1738915144248373,677427.3504996448,0.2817443174278134), (51,1040,...
另请参阅相关C++方法的文档
pagmo::pso::get_log()。
- class pygmo.nsga2(gen=1, cr=0.95, eta_c=10., m=0.01, eta_m=50., seed=random)#
非支配排序遗传算法 (NSGA-II)。
- Parameters
- Raises
OverflowError – 如果 gen 或 seed 为负数或大于实现定义的值
ValueError – 如果 cr 不在 [0,1[ 范围内，eta_c 不在 [0,100[ 范围内，m 不在 [0,1] 范围内，或者 eta_m 不在 [0,100[ 范围内
另请参阅C++类
pagmo::nsga2的文档。- get_log()#
返回一个日志，包含上次调用
evolve()时记录的相关参数并打印到屏幕上。日志频率取决于详细程度参数（默认情况下不记录任何内容），可以通过在构造algorithm时调用set_verbosity()方法来设置，该算法使用nsga2构建。详细程度为N意味着每N代记录一行日志。- Returns
在每个记录的时期，值
Gen,Fevals,ideal_point，其中：- Return type
示例
>>> from pygmo import * >>> algo = algorithm(nsga2(gen=100)) >>> algo.set_verbosity(20) >>> pop = population(zdt(1), 40) >>> pop = algo.evolve(pop) Gen: Fevals: ideal1: ideal2: 1 0 0.0033062 2.44966 21 800 0.000275601 0.893137 41 1600 3.15834e-05 0.44117 61 2400 2.3664e-05 0.206365 81 3200 2.3664e-05 0.133305 >>> uda = algo.extract(nsga2) >>> uda.get_log() [(1, 0, array([ 0.0033062 , 2.44965599])), (21, 800, array([ 2.75601086e-04 ...
另请参阅相关C++方法的文档
pagmo::nsga2::get_log()。
- class pygmo.nspso(gen=1, omega=0.6, c1=0.01, c2=0.5, chi=0.5, v_coeff=0.5, leader_selection_range=2, diversity_mechanism='crowding distance', memory=false, seed=random)#
非支配排序粒子群优化（NSPSO）。
- Parameters
- Raises
OverflowError – 如果 gen 或 seed 为负数或大于实现定义的值
ValueError – 如果 omega < 0 或 c1 <= 0 或 c2 <= 0 或 chi <= 0，或者如果 omega > 1，
如果 v_coeff <= 0 或 v_coeff > 1, 如果 leader_selection_range > 100, 如果 diversity_mechanism != "crowding distance", 或 != "niche count", 或 != "max min" –
另请参阅C++类
pagmo::nspso的文档。- get_log()#
返回一个日志，包含上次调用
evolve()时记录的相关参数并打印到屏幕上。日志频率取决于详细程度参数（默认情况下不记录任何内容），可以通过在构造的algorithm上调用方法set_verbosity()来设置，该算法使用nspso构建。详细程度为N意味着每N代记录一行日志。- Returns
在每个记录的时期，值
Gen,Fevals,ideal_point，其中：- Return type
示例
>>> from pygmo import * >>> algo = algorithm(nspso(gen=100)) >>> algo.set_verbosity(20) >>> pop = population(zdt(1), 40) >>> pop = algo.evolve(pop) Gen: Fevals: ideal1: ideal2: 1 40 0.019376 2.75209 21 840 0 1.97882 41 1640 0 1.88428 61 2440 0 1.88428 81 3240 0 1.88428 >>> uda = algo.extract(nspso) >>> uda.get_log() [(1, 40, array([0.04843319, 2.98129814])), (21, 840, array([0., 1.68331679])) ...
另请参阅相关C++方法的文档
pagmo::nspso::get_log()。
- class pygmo.mbh(algo=None, stop=5, perturb=0.01, seed=None)#
单调盆地跳跃（广义）。
单调盆地跳跃，或简称为盆地跳跃，是一种基于将目标函数\(f(\mathbf x_0)\)映射到从\(\mathbf x_0\)开始的局部最小值的算法。这个简单的想法在解决诸如Lennard-Jones团簇或MGA-1DSM星际轨迹问题时，可以显著提高效率，这些问题被认为具有所谓的漏斗结构。
在pygmo中，我们提供了这一概念的原始泛化，形成了一个元算法，该算法可以在任何
pygmo.population上操作，使用任何合适的用户定义算法（UDA）。当使用包含单个个体的种群并与局部优化器结合时，原始方法得以恢复。我们泛化版本的伪代码如下：> Select a pygmo population > Select a UDA > Store best individual > while i < stop_criteria > > Perturb the population in a selected neighbourhood > > Evolve the population using the algorithm > > if the best individual is improved > > > increment i > > > update best individual > > else > > > i = 0
pygmo.mbh是一个用户定义的算法（UDA），可用于构建pygmo.algorithm对象。参见：https://arxiv.org/pdf/cond-mat/9803344.pdf 了解关于Lennard-Jones簇优化的盆地跳跃思想的论文。
另请参阅C++类
pagmo::mbh的文档。- Parameters
- Raises
ValueError – 如果 perturb（或其组件之一，如果 perturb 是数组）不在 (0,1] 范围内
未指定 – 由
pygmo.algorithm的构造函数抛出的任何异常，或由C++和Python之间的交互失败引起的异常（例如，类型转换错误，函数签名不匹配等）。
- get_log()#
返回一个日志，包含上次调用
evolve()期间记录的相关参数。日志频率取决于详细程度参数（默认情况下不记录任何内容），可以通过在构造的algorithm上调用set_verbosity()来设置，该算法使用mbh构建。详细程度级别N > 0将在每次调用内部算法结束时记录一行。- Returns
at each call of the inner algorithm, the values
Fevals,Best,Violated,Viol. NormandTrial, where:Fevals(int), the number of fitness evaluations madeBest(float), the objective function of the best fitness currently in the populationViolated(int), the number of constraints currently violated by the best solutionViol. Norm(float), the norm of the violation (discounted already by the constraints tolerance)Trial(int), the trial number (which will determine the algorithm stop)
- Return type
示例
>>> from pygmo import * >>> algo = algorithm(mbh(algorithm(de(gen = 10)))) >>> algo.set_verbosity(3) >>> prob = problem(cec2013(prob_id = 1, dim = 20)) >>> pop = population(prob, 20) >>> pop = algo.evolve(pop) Fevals: Best: Violated: Viol. Norm: Trial: 440 25162.3 0 0 0 880 14318 0 0 0 1320 11178.2 0 0 0 1760 6613.71 0 0 0 2200 6613.71 0 0 1 2640 6124.62 0 0 0 3080 6124.62 0 0 1
另请参阅相关C++方法的文档
pagmo::mbh::get_log()。
- get_perturb()#
获取扰动向量。
- Returns
扰动向量
- Return type
一维NumPy浮点数数组
- set_perturb(perturb)#
设置扰动向量。
- Parameters
perturb (array-like object) – 对每个组件应用的扰动
- Raises
未指定 – 任何由C++和Python之间的失败引发的异常（例如，类型转换错误、函数签名不匹配等）
- class pygmo.cstrs_self_adaptive(iters=1, algo=None, seed=None)#
此元算法实现了一种约束处理技术，该技术允许在单目标约束问题上使用任何能够处理单目标无约束问题的用户定义算法（UDA）。该技术在每次连续调用内部UDA时，基于整个基础种群自适应其参数。所得到的方法是使用元问题
unconstrain将约束适应度转换为无约束适应度的替代方案。自适应约束处理元算法主要基于Faramani和Wright的思想，但它将其应用扩展到任何算法，特别是非代际、基于种群的进化方法，其中使用稳态重新插入（即一旦发现个体适合，立即将其重新插入种群，并影响下一代遗传物质）。
每个决策向量都被分配了一个不可行性度量\(\iota\)，它考虑了所有约束的归一化违反情况（通过
pygmo.problem.c_tol返回的约束容差进行折扣）。使用的归一化因子\(c_{j_{max}}\)是\(j\)约束的最大违反值。正如原始论文中所述，进化种群中的三个个体随后被用来惩罚单一目标。
\[\begin{split}\begin{array}{rl} \check X & \mbox{: the best decision vector} \\ \hat X & \mbox{: the worst decision vector} \\ \breve X & \mbox{: the decision vector with the highest objective} \end{array}\end{split}\]最佳和最差决策向量的定义考虑了它们的不可行性和目标函数的值。使用上述定义，整体伪代码可以总结如下：
> Select a pygmo.population (related to a single-objective constrained problem) > Select a UDA (able to solve single-objective unconstrained problems) > while i < iter > > Compute the normalization factors (will depend on the current population) > > Compute the best, worst, highest (will depend on the current population) > > Evolve the population using the UDA and a penalized objective > > Reinsert the best decision vector from the previous evolution
pygmo.cstrs_self_adaptive是一个用户定义的算法（UDA），可用于构建pygmo.algorithm对象。注意
自适应约束处理实现了一个内部缓存，以避免对已经评估过的决策向量重新评估适应度。这使得最终的适应度评估计数有些不可预测。函数评估的次数将被限制为iters乘以对内部UDA的一次调用所进行的fevals。内部缓存在每次迭代时重置，但其大小在每次调用内部UDA的evolve方法期间将无限增长。
注意
对原始的Faramani和Wright的想法进行了几处修改，以使他们的方法能够在极端情况下工作，并且适用于任何UDA。最值得注意的是，如果种群中的所有决策向量都满足特定的约束条件（即如果\(c_{j_{max}} = 0\)），则忽略对第\(j\)个约束的违反。
注意
cstrs_self_adaptive的性能高度依赖于所采用的特定内部算法，尤其是其参数（代数/迭代次数）。另请参阅
Farmani, Raziyeh, 和 Jonathan A. Wright. “用于约束优化的自适应适应度公式。” IEEE 进化计算汇刊 7.5 (2003): 445-455.
另请参阅C++类
pagmo::cstrs_self_adaptive的文档。- Parameters
- Raises
ValueError – 如果 iters 为负数或大于实现定义的值
未指定 – 由
pygmo.algorithm的构造函数抛出的任何异常，或由C++和Python之间的交互失败引起的异常（例如，类型转换错误，函数签名不匹配等）。
- get_log()#
返回一个包含上次调用
evolve()期间记录的相关参数的日志。日志频率取决于详细程度参数（默认情况下不记录任何内容），可以通过在构造的algorithm上调用set_verbosity()来设置，该算法使用cstrs_self_adaptive构建。详细程度级别为N > 0时，每N次iters记录一行。- Returns
at each call of the inner algorithm, the values
Iters,Fevals,Best,Infeasibility,Violated,Viol. NormandN. Feasible, where:Iters(int), the number of iterations made (i.e. calls to the evolve method of the inner algorithm)Fevals(int), the number of fitness evaluations madeBest(float), the objective function of the best fitness currently in the populationInfeasibility(float), the aggregated (and normalized) infeasibility value ofBestViolated(int), the number of constraints currently violated by the best solutionViol. Norm(float), the norm of the violation (discounted already by the constraints tolerance)N. Feasible(int), the number of feasible individuals currently in the population.
- Return type
示例
>>> from pygmo import * >>> algo = algorithm(cstrs_self_adaptive(iters = 20, algo = de(10))) >>> algo.set_verbosity(3) >>> prob = problem(cec2006(prob_id = 1)) >>> pop = population(prob, 20) >>> pop = algo.evolve(pop) Iter: Fevals: Best: Infeasibility: Violated: Viol. Norm: N. Feasible: 1 0 -96.5435 0.34607 4 177.705 0 i 4 600 -96.5435 0.360913 4 177.705 0 i 7 1200 -96.5435 0.36434 4 177.705 0 i 10 1800 -96.5435 0.362307 4 177.705 0 i 13 2400 -23.2502 0.098049 4 37.1092 0 i 16 3000 -23.2502 0.071571 4 37.1092 0 i 19 3600 -23.2502 0.257604 4 37.1092 0 i >>> uda = algo.extract(moead) >>> uda.get_log() [(1, 0, -96.54346700540063, 0.34606950943401493, 4, 177.70482046341274, 0), (4, 600, ...
另请参阅相关C++方法的文档
pagmo::cstrs_self_adaptive::get_log()。
- class pygmo.nlopt(solver='cobyla')#
NLopt算法。
这个用户定义的算法封装了来自NLopt库的一系列求解器，专注于局部优化（包括基于梯度和无导数的方法）。支持的NLopt算法完整列表如下：
COBYLA,
BOBYQA,
NEWUOA + 边界约束,
实践,
Nelder-Mead单纯形法，
sbplx,
MMA（移动渐近线法），
中国通信标准化协会,
SLSQP,
低存储BFGS，
预处理的截断牛顿法，
移位的有限内存变量度量，
增强拉格朗日算法。
所需的NLopt求解器在构建
nlopt算法时被选择。求解器的各种属性（例如，停止标准）可以通过类属性进行配置。多个停止标准可以同时激活：一旦至少一个停止标准被满足，优化将停止。默认情况下，只有xtol_rel停止标准是激活的（参见xtol_rel）。所有NLopt求解器仅支持单目标优化，并且，像在pygmo中一样，总是假设为最小化。基于梯度的算法要求优化问题提供梯度。一些求解器支持等式和/或不等式约束。约束的容差将设置为被优化的
problem中指定的容差（参见pygmo.problem.c_tol）。为了支持pygmo的基于群体的优化模型，
evolve()方法将从输入的population中选择一个个体，由NLopt求解器进行优化。 如果优化产生了一个更好的个体（由compare_fc()确定），优化后的个体将被重新插入到群体中。 选择和替换策略可以通过selection和replacement属性进行配置。注意
此用户定义算法仅在pygmo编译时启用了
PAGMO_WITH_NLOPT选项时可用（请参阅安装说明）。另请参阅
NLopt 网站包含每个支持的求解器的详细描述。
此构造函数将初始化一个
nlopt对象，该对象将使用由输入字符串solver指定的NLopt算法，"best"个体选择策略和"best"个体替换策略。solver根据以下转换表转换为NLopt算法类型：solver 字符串
NLopt算法
"cobyla"NLOPT_LN_COBYLA"bobyqa"NLOPT_LN_BOBYQA"newuoa"NLOPT_LN_NEWUOA"newuoa_bound"NLOPT_LN_NEWUOA_BOUND"praxis"NLOPT_LN_PRAXIS"neldermead"NLOPT_LN_NELDERMEAD"sbplx"NLOPT_LN_SBPLX"mma"NLOPT_LD_MMA"ccsaq"NLOPT_LD_CCSAQ"slsqp"NLOPT_LD_SLSQP"lbfgs"NLOPT_LD_LBFGS"tnewton_precond_restart"NLOPT_LD_TNEWTON_PRECOND_RESTART"tnewton_precond"NLOPT_LD_TNEWTON_PRECOND"tnewton_restart"NLOPT_LD_TNEWTON_RESTART"tnewton"NLOPT_LD_TNEWTON"var2"NLOPT_LD_VAR2"var1"NLOPT_LD_VAR1"auglag"NLOPT_AUGLAG"auglag_eq"NLOPT_AUGLAG_EQ所选求解器的参数可以通过此类的属性进行配置。
另请参阅C++类
pagmo::nlopt的文档。另请参阅
NLopt 网站包含每个支持的求解器的详细描述。
- Parameters
- Raises
RuntimeError – 如果NLopt版本低于2
ValueError – 如果 solver 不是允许的算法名称之一
未指定 – 任何由C++和Python之间的失败引发的异常（例如，类型转换错误、函数签名不匹配等）。
示例
>>> from pygmo import * >>> nl = nlopt('slsqp') >>> nl.xtol_rel = 1E-6 # Change the default value of the xtol_rel stopping criterion >>> nl.xtol_rel 1E-6 >>> algo = algorithm(nl) >>> algo.set_verbosity(1) >>> prob = problem(luksan_vlcek1(20)) >>> prob.c_tol = [1E-6] * 18 # Set constraints tolerance to 1E-6 >>> pop = population(prob, 20) >>> pop = algo.evolve(pop) objevals: objval: violated: viol. norm: 1 95959.4 18 538.227 i 2 89282.7 18 5177.42 i 3 75580 18 464.206 i 4 75580 18 464.206 i 5 77737.6 18 1095.94 i 6 41162 18 350.446 i 7 41162 18 350.446 i 8 67881 18 362.454 i 9 30502.2 18 249.762 i 10 30502.2 18 249.762 i 11 7266.73 18 95.5946 i 12 4510.3 18 42.2385 i 13 2400.66 18 35.2507 i 14 34051.9 18 749.355 i 15 1657.41 18 32.1575 i 16 1657.41 18 32.1575 i 17 1564.44 18 12.5042 i 18 275.987 14 6.22676 i 19 232.765 12 12.442 i 20 161.892 15 4.00744 i 21 161.892 15 4.00744 i 22 17.6821 11 1.78909 i 23 7.71103 5 0.130386 i 24 6.24758 4 0.00736759 i 25 6.23325 1 5.12547e-05 i 26 6.2325 0 0 27 6.23246 0 0 28 6.23246 0 0 29 6.23246 0 0 30 6.23246 0 0 Optimisation return status: NLOPT_XTOL_REACHED (value = 4, Optimization stopped because xtol_rel or xtol_abs was reached)
- property ftol_abs#
ftol_abs停止准则。ftol_abs停止准则指示求解器在优化步骤（或最优值的估计）使函数值变化小于ftol_abs时停止。默认值为 0（即默认情况下此停止准则被禁用）。- Returns
ftol_abs停止准则的值- Return type
- Raises
ValueError – 如果在设置此属性时传递了
NaN未指定 – 任何由C++和Python之间的失败引发的异常（例如，类型转换错误、函数签名不匹配等）。
- property ftol_rel#
ftol_rel停止准则。ftol_rel停止准则指示求解器在优化步骤（或最优值的估计）使目标函数值的变化小于ftol_rel乘以函数值的绝对值时停止。默认值为 0（即默认情况下此停止准则被禁用）。- Returns
ftol_rel停止准则的值- Return type
- Raises
ValueError – 如果设置此属性时传递了
NaN未指定 – 任何由C++和Python之间的失败引发的异常（例如，类型转换错误、函数签名不匹配等）。
- get_last_opt_result()#
获取上次优化的结果。
- Returns
最后一次优化运行的NLopt返回代码，如果尚未运行任何优化，则为
NLOPT_SUCCESS- Return type
- Raises
未指定 – 任何由C++和Python之间的失败引发的异常（例如，类型转换错误、函数签名不匹配等）。
- get_log()#
优化日志。
优化日志是日志数据行的集合。日志数据行是一个由以下内容组成的元组：
到目前为止目标函数评估的次数，
当前决策向量的目标函数值，
当前决策向量违反的约束数量，
当前决策向量的约束违反范数，
一个布尔标志，表示当前决策向量的可行性。
- Returns
优化日志
- Return type
- Raises
未指定 – 任何由C++和Python之间的失败引发的异常（例如，类型转换错误、函数签名不匹配等）。
- get_solver_name()#
获取构建过程中使用的NLopt求解器的名称。
- Returns
构建过程中使用的NLopt求解器的名称
- Return type
- Raises
未指定 – 任何由C++和Python之间的失败引发的异常（例如，类型转换错误、函数签名不匹配等）。
- property local_optimizer#
本地优化器。
一些NLopt算法依赖于其他NLopt算法作为局部/辅助优化器。 此属性类型为
nlopt，允许设置此类局部优化器。 默认情况下，未指定局部优化器，属性设置为None。注意
目前，只有
"auglag"和"auglag_eq"求解器使用了局部优化器。在任何其他求解器上设置局部优化器将不会有任何效果。注意
局部优化器的目标函数、边界和非线性约束参数被忽略（因为它们由父优化器提供）。相反，停止标准应在局部优化器中指定。在优化过程中，局部优化器的详细程度也被强制设置为零。
- Returns
本地优化器，如果未设置则为
None- Return type
- Raises
未指定 – 在设置属性时，由C++和Python之间的失败引发的任何异常 （例如，类型转换错误、函数签名不匹配等）。
- property maxeval#
maxeval停止准则。maxeval停止准则指示求解器在函数评估次数超过maxeval时停止。默认值为 0（即默认情况下此停止准则被禁用）。- Returns
maxeval停止准则的值- Return type
- Raises
未指定 – 任何由C++和Python之间的失败引发的异常（例如，类型转换错误、函数签名不匹配等）。
- property maxtime#
maxtime停止准则。maxtime停止准则指示求解器在优化时间（以秒为单位）超过maxtime时停止。默认值为 0（即默认情况下此停止准则被禁用）。- Returns
maxtime停止准则的值- Return type
- Raises
未指定 – 任何由C++和Python之间的失败引发的异常（例如，类型转换错误、函数签名不匹配等）。
- property replacement#
个体替换策略。
此属性表示在
evolve()方法中用于选择将被优化个体替换的个体的策略。该属性可以是字符串或整数。如果属性是字符串，它必须是
"best"、"worst"和"random"之一："best"将选择种群中的最佳个体，"worst"将选择种群中最差的个体，"random"将在种群中随机选择一个个体。
set_random_sr_seed()可用于为"random"策略使用的随机数生成器设置种子。如果属性是整数，它表示将被优化个体替换的个体在种群中的索引。
- Returns
个人替换策略或索引
- Return type
- Raises
OverflowError – 如果属性设置为负数或过大的整数
ValueError – 如果属性设置为无效字符串
TypeError – 如果属性设置为无效类型的值
未指定 – 任何由C++和Python之间的失败引发的异常（例如，类型转换错误、函数签名不匹配等）。
- property selection#
个体选择策略。
此属性表示在
evolve()方法中用于选择将被优化的个体的策略。该属性可以是字符串或整数。如果属性是字符串，它必须是
"best"、"worst"和"random"之一："best"将选择种群中的最佳个体，"worst"将选择种群中最差的个体，"random"将在种群中随机选择一个个体。
set_random_sr_seed()可用于为"random"策略使用的随机数生成器设置种子。如果属性是整数，它表示被选中进行优化的个体在种群中的索引。
- Returns
个体选择策略或索引
- Return type
- Raises
OverflowError – 如果属性设置为负数或过大的整数
ValueError – 如果属性设置为无效字符串
TypeError – 如果属性设置为无效类型的值
未指定 – 任何由C++和Python之间的失败引发的异常（例如，类型转换错误、函数签名不匹配等）。
- set_random_sr_seed(seed)#
为
"random"选择/替换策略设置种子。- Parameters
seed (
int) – 用于播种随机数生成器的值，该生成器由"random"选举/替换策略使用（参见selection和replacement）- Raises
OverflowError – 如果属性设置为负数或过大的整数
未指定 – 任何由C++和Python之间的失败引发的异常（例如，类型转换错误、函数签名不匹配等）。
- property stopval#
stopval停止准则。stopval停止准则指示求解器在找到小于或等于stopval的目标值时停止。默认值为 C 常量-HUGE_VAL（即默认情况下此停止准则被禁用）。- Returns
stopval停止准则的值- Return type
- Raises
ValueError – 如果设置此属性时传递了
NaN未指定 – 任何由C++和Python之间的失败引发的异常（例如，类型转换错误、函数签名不匹配等）。
- property xtol_abs#
xtol_abs停止准则。xtol_abs停止准则指示求解器在优化步骤（或最优估计）使每个参数的变化小于xtol_abs时停止。默认值为 0（即默认情况下此停止准则被禁用）。- Returns
xtol_abs停止准则的值- Return type
- Raises
ValueError – 如果设置此属性时传递了
NaN未指定 – 任何由C++和Python之间的失败引发的异常（例如，类型转换错误、函数签名不匹配等）。
- property xtol_rel#
xtol_rel停止准则。xtol_rel停止准则指示求解器在优化步骤（或最优值的估计）使每个参数的变化小于xtol_rel乘以参数的绝对值时停止。默认值为 1E-8。- Returns
xtol_rel停止准则的值- Return type
- Raises
ValueError – 如果设置此属性时传递了
NaN未指定 – 任何由C++和Python之间的失败引发的异常（例如，类型转换错误、函数签名不匹配等）。
- class pygmo.ipopt#
Ipopt。
版本2.2中的新功能。
该类是一个用户定义的算法（UDA），它封装了Ipopt（内点优化器）求解器，这是一个用于大规模非线性优化的软件包。Ipopt是一个强大的求解器，能够稳健且高效地处理高维度的约束非线性优化问题。
Ipopt 仅支持单目标最小化，并且要求在优化问题中提供梯度。如果可能，为了获得最佳结果，还应提供 Hessian 矩阵（但 Ipopt 可以在需要时数值估计 Hessian 矩阵）。
为了支持pygmo的基于群体的优化模型，
evolve()方法将从输入的population中选择一个个体进行优化。 如果优化产生了一个更好的个体（由compare_fc()确定），优化后的个体将被重新插入到群体中。选择和替换策略可以通过selection和replacement属性进行配置。Ipopt 支持大量用于优化运行配置的选项。这些选项分为三类：
完整的选项列表可在Ipopt网站上找到。
pygmo.ipopt允许通过诸如set_string_options(),set_string_option(),set_integer_options()等方法来配置任何 Ipopt 选项，这些方法需要在调用evolve()方法之前使用。如果用户没有设置任何选项，
pygmo.ipopt将使用 Ipopt 的默认选项值（参见文档），并进行以下修改：如果用户没有设置
"print_level"整数选项，它将被pygmo.ipopt设置为0（这将抑制求解器产生的大部分屏幕输出 - 请注意，我们支持通过pygmo.algorithm.set_verbosity()机制进行另一种形式的日志记录）；如果用户没有设置
"hessian_approximation"字符串选项，并且优化问题没有提供Hessians，那么pygmo.ipopt将自动将该选项设置为"limited-memory"。这使得无需Hessians即可开箱即用地优化问题（即Ipopt将为您数值近似Hessians）；如果用户没有设置
"constr_viol_tol"数值选项并且优化问题是受约束的， 那么pygmo.ipopt将计算pygmo.problem.c_tol返回的向量中的最小值min_tol对于当前的优化问题。如果min_tol不为零，则"constr_viol_tol"Ipopt选项将 设置为min_tol，否则将使用Ipopt的默认值（1E-4）作为选项。这确保了， 如果用户没有明确设置约束容差，Ipopt认为可行的解也被 pygmo认为是可行的（但反之则不一定成立）。
注意
此用户定义算法仅在pygmo编译时启用了
PAGMO_WITH_IPOPT选项时可用（请参阅安装说明）。注意
Ipopt 不是线程安全的，因此它不能在
pygmo.thread_island中使用。另请参阅C++类
pagmo::ipopt的文档。示例
>>> from pygmo import * >>> ip = ipopt() >>> ip.set_numeric_option("tol",1E-9) # Change the relative convergence tolerance >>> ip.get_numeric_options() {'tol': 1e-09} >>> algo = algorithm(ip) >>> algo.set_verbosity(1) >>> prob = problem(luksan_vlcek1(20)) >>> prob.c_tol = [1E-6] * 18 # Set constraints tolerance to 1E-6 >>> pop = population(prob, 20) >>> pop = algo.evolve(pop) ****************************************************************************** This program contains Ipopt, a library for large-scale nonlinear optimization. Ipopt is released as open source code under the Eclipse Public License (EPL). For more information visit https://coin-or.github.io/Ipopt/ ****************************************************************************** objevals: objval: violated: viol. norm: 1 201174 18 1075.3 i 2 209320 18 691.814 i 3 36222.3 18 341.639 i 4 11158.1 18 121.097 i 5 4270.38 18 46.4742 i 6 2054.03 18 20.7306 i 7 705.959 18 5.43118 i 8 37.8304 18 1.52099 i 9 2.89066 12 0.128862 i 10 0.300807 3 0.0165902 i 11 0.00430279 3 0.000496496 i 12 7.54121e-06 2 9.70735e-06 i 13 4.34249e-08 0 0 14 3.71925e-10 0 0 15 3.54406e-13 0 0 16 2.37071e-18 0 0 Optimisation return status: Solve_Succeeded (value = 0)
- get_integer_options()#
获取整数选项。
示例
>>> from pygmo import * >>> ip = ipopt() >>> ip.set_integer_option("print_level",3) >>> ip.get_integer_options() {'print_level': 3}
- get_last_opt_result()#
获取上次优化的结果。
- Returns
最后一次优化运行的Ipopt返回代码，如果尚未运行任何优化，则为
Ipopt::Solve_Succeeded- Return type
- Raises
未指定 – 任何由C++和Python之间的失败引发的异常（例如，类型转换错误、函数签名不匹配等）。
示例
>>> from pygmo import * >>> ip = ipopt() >>> ip.get_last_opt_result() 0
- get_log()#
优化日志。
优化日志是日志数据行的集合。日志数据行是一个由以下内容组成的元组：
到目前为止目标函数评估的次数，
当前决策向量的目标函数值，
当前决策向量违反的约束数量，
当前决策向量的约束违反范数，
一个布尔标志，表示当前决策向量的可行性。
- Returns
优化日志
- Return type
- Raises
未指定 – 任何由C++和Python之间的失败引发的异常（例如，类型转换错误、函数签名不匹配等）。
警告
违反约束的数量、约束违反规范和存储在日志中的可行性标志都是通过
pygmo.problem中指定的设施和容差来确定的。也就是说，它们可能不一定与Ipopt的可行性概念一致。请参阅pygmo.ipopt中如何处理"constr_viol_tol"数值选项的解释。注意
Ipopt 支持其自己的日志格式和协议，包括打印到屏幕和写入文件的能力。 Ipopt 的屏幕日志记录默认是禁用的（即，Ipopt 的详细程度设置设置为 0 - 参见
pygmo.ipopt）。可以通过"print_level"字符串选项启用屏幕日志记录。
- get_numeric_options()#
获取数字选项。
示例
>>> from pygmo import * >>> ip = ipopt() >>> ip.set_numeric_option("tol",1E-4) >>> ip.get_numeric_options() {'tol': 1E-4}
- get_string_options()#
获取字符串选项。
示例
>>> from pygmo import * >>> ip = ipopt() >>> ip.set_string_option("hessian_approximation","limited-memory") >>> ip.get_string_options() {'hessian_approximation': 'limited-memory'}
- property replacement#
个体替换策略。
此属性表示在
evolve()方法中用于选择将被优化个体替换的个体的策略。该属性可以是字符串或整数。如果属性是字符串，它必须是
"best"、"worst"和"random"之一："best"将选择种群中的最佳个体，"worst"将选择种群中最差的个体，"random"将在种群中随机选择一个个体。
set_random_sr_seed()可用于为"random"策略使用的随机数生成器设置种子。如果属性是整数，它表示将被优化个体替换的个体在种群中的索引。
- Returns
个人替换策略或索引
- Return type
- Raises
OverflowError – 如果属性设置为负数或过大的整数
ValueError – 如果属性设置为无效字符串
TypeError – 如果属性设置为无效类型的值
未指定 – 任何由C++和Python之间的失败引发的异常（例如，类型转换错误、函数签名不匹配等）。
- reset_integer_options()#
清除所有整数选项。
示例
>>> from pygmo import * >>> ip = ipopt() >>> ip.set_integer_option("print_level",3) >>> ip.get_integer_options() {'print_level': 3} >>> ip.reset_integer_options() >>> ip.get_integer_options() {}
- reset_numeric_options()#
清除所有数字选项。
示例
>>> from pygmo import * >>> ip = ipopt() >>> ip.set_numeric_option("tol",1E-4) >>> ip.get_numeric_options() {'tol': 1E-4} >>> ip.reset_numeric_options() >>> ip.get_numeric_options() {}
- reset_string_options()#
清除所有字符串选项。
示例
>>> from pygmo import * >>> ip = ipopt() >>> ip.set_string_option("hessian_approximation","limited-memory") >>> ip.get_string_options() {'hessian_approximation': 'limited-memory'} >>> ip.reset_string_options() >>> ip.get_string_options() {}
- property selection#
个体选择策略。
此属性表示在
evolve()方法中用于选择将被优化的个体的策略。该属性可以是字符串或整数。如果属性是字符串，它必须是
"best"、"worst"和"random"之一："best"将选择种群中的最佳个体，"worst"将选择种群中最差的个体，"random"将在种群中随机选择一个个体。
set_random_sr_seed()可用于为"random"策略使用的随机数生成器设置种子。如果属性是整数，它表示被选中进行优化的个体在种群中的索引。
- Returns
个体选择策略或索引
- Return type
- Raises
OverflowError – 如果属性设置为负数或过大的整数
ValueError – 如果属性设置为无效字符串
TypeError – 如果属性设置为无效类型的值
未指定 – 任何由C++和Python之间的失败引发的异常（例如，类型转换错误、函数签名不匹配等）。
- set_integer_option(name, value)#
设置整数选项。
此方法将优化整数选项name设置为value。 优化选项在调用
evolve()方法时传递给Ipopt API。- Parameters
- Raises
未指定 – 任何由C++和Python之间的失败引发的异常（例如，类型转换错误、函数签名不匹配等）。
示例
>>> from pygmo import * >>> ip = ipopt() >>> ip.set_integer_option("print_level",3) >>> algorithm(ip) Algorithm name: Ipopt: Interior Point Optimization [deterministic] C++ class name: ... Thread safety: none Extra info: Last optimisation return code: Solve_Succeeded (value = 0) Verbosity: 0 Individual selection policy: best Individual replacement policy: best Integer options: {print_level : 3}
- set_integer_options(opts)#
设置整数选项。
此方法将设置包含在opts中的优化整数选项。 它等同于调用
set_integer_option()，将opts中的所有名称-值对作为参数传递。- Parameters
- Raises
未指定 – 任何由C++和Python之间的失败引发的异常（例如，类型转换错误、函数签名不匹配等）。
示例
>>> from pygmo import * >>> ip = ipopt() >>> ip.set_integer_options({"filter_reset_trigger":4, "print_level":3}) >>> algorithm(ip) Algorithm name: Ipopt: Interior Point Optimization [deterministic] C++ class name: ... Thread safety: none Extra info: Last optimisation return code: Solve_Succeeded (value = 0) Verbosity: 0 Individual selection policy: best Individual replacement policy: best Integer options: {filter_reset_trigger : 4, print_level : 3}
- set_numeric_option(name, value)#
设置数值选项。
此方法将优化数值选项name设置为value。 优化选项在调用
evolve()方法时传递给Ipopt API。- Parameters
- Raises
未指定 – 任何由C++和Python之间的失败引发的异常（例如，类型转换错误、函数签名不匹配等）。
示例
>>> from pygmo import * >>> ip = ipopt() >>> ip.set_numeric_option("tol",1E-6) >>> algorithm(ip) Algorithm name: Ipopt: Interior Point Optimization [deterministic] C++ class name: ... Thread safety: none Extra info: Last optimisation return code: Solve_Succeeded (value = 0) Verbosity: 0 Individual selection policy: best Individual replacement policy: best Numeric options: {tol : 1E-6}
- set_numeric_options(opts)#
设置数值选项。
此方法将设置包含在opts中的优化数值选项。 它等同于调用
set_numeric_option()，将opts中的所有名称-值对作为参数传递。- Parameters
- Raises
未指定 – 任何由C++和Python之间的失败引发的异常（例如，类型转换错误、函数签名不匹配等）。
示例
>>> from pygmo import * >>> ip = ipopt() >>> ip.set_numeric_options({"tol":1E-4, "constr_viol_tol":1E-3}) >>> algorithm(ip) Algorithm name: Ipopt: Interior Point Optimization [deterministic] C++ class name: ... Thread safety: none Extra info: Last optimisation return code: Solve_Succeeded (value = 0) Verbosity: 0 Individual selection policy: best Individual replacement policy: best Numeric options: {constr_viol_tol : 1E-3, tol : 1E-4}
- set_random_sr_seed(seed)#
为
"random"选择/替换策略设置种子。- Parameters
seed (
int) – 用于播种随机数生成器的值，该生成器由"random"选举/替换策略使用（参见selection和replacement）- Raises
OverflowError – 如果属性设置为负数或过大的整数
未指定 – 任何由C++和Python之间的失败引发的异常（例如，类型转换错误、函数签名不匹配等）。
- set_string_option(name, value)#
设置字符串选项。
此方法将优化字符串选项name设置为value。 优化选项在调用
evolve()方法时传递给Ipopt API。- Parameters
- Raises
未指定 – 任何由C++和Python之间的失败引发的异常（例如，类型转换错误、函数签名不匹配等）。
示例
>>> from pygmo import * >>> ip = ipopt() >>> ip.set_string_option("hessian_approximation","limited-memory") >>> algorithm(ip) Algorithm name: Ipopt: Interior Point Optimization [deterministic] C++ class name: ... Thread safety: none Extra info: Last optimisation return code: Solve_Succeeded (value = 0) Verbosity: 0 Individual selection policy: best Individual replacement policy: best String options: {hessian_approximation : limited-memory}
- set_string_options(opts)#
设置字符串选项。
此方法将设置包含在opts中的优化字符串选项。 它等同于调用
set_string_option()，将opts中的所有名称-值对作为参数传递。- Parameters
- Raises
未指定 – 任何由C++和Python之间的失败引发的异常（例如，类型转换错误、函数签名不匹配等）。
示例
>>> from pygmo import * >>> ip = ipopt() >>> ip.set_string_options({"hessian_approximation":"limited-memory", "limited_memory_initialization":"scalar1"}) >>> algorithm(ip) Algorithm name: Ipopt: Interior Point Optimization [deterministic] C++ class name: ... Thread safety: none Extra info: Last optimisation return code: Solve_Succeeded (value = 0) Verbosity: 0 Individual selection policy: best Individual replacement policy: best String options: {hessian_approximation : limited-memory, limited_memory_initialization : scalar1}
- class pygmo.ihs(gen=1, phmcr=0.85, ppar_min=0.35, ppar_max=0.99, bw_min=1e-5, bw_max=1., seed=random)#
和谐搜索（HS）是一种元启发式算法，据说模仿了音乐家的即兴创作过程。 在这个比喻中，每个音乐家（即每个变量）演奏（即生成）一个音符（即一个值） 以共同找到最佳和谐（即全局最优解）。
这个pygmo UDA实现了所谓的改进和声搜索算法（IHS），在该算法中，每次调用
evolve()方法时，从决策向量中选择变量的概率以及它们所经历的变异量（分别线性和指数地）会发生变化。在此算法中，适应度函数的评估次数等于迭代次数。 输入种群中的所有个体都参与进化。每次迭代都会生成一个新个体，如果更好，则替换当前种群中最差的个体。
警告
HS算法可以并且已经受到批评，不是因为它的性能，而是因为使用了一个没有为现有方法增添任何内容的隐喻。HS算法本质上是对背景种群应用变异和交叉操作，因此应该在进化策略或遗传算法的背景下开发，并在该背景下进行研究。使用音乐家的隐喻只会掩盖其内部运作，使得来自ES和GA的理论结果错误地看起来不适用于HS。
注意
原始的IHS算法旨在解决无约束、确定性的单目标问题。 在pygmo中，该算法被修改以处理多目标、约束（线性和非线性）问题。 这种扩展是pygmo独有的。
- Parameters
- Raises
OverflowError – 如果 gen 或 seed 为负数或大于实现定义的值
ValueError – 如果 phmcr 不在 ]0,1[ 区间内，ppar_min 或 ppar_max 不在 ]0,1[ 区间内，最小/最大数量小于/大于最大/最小数量，bw_min 为负数。
未指定 – 任何由C++和Python之间的交互失败引发的异常 （例如，类型转换错误，函数签名不匹配等）
另请参阅C++类
pagmo::ihs的文档。- get_log()#
返回一个日志，包含上次调用
evolve()期间记录的相关参数并打印到屏幕上。 日志频率取决于详细程度参数（默认情况下不记录任何内容），可以通过在构造的algorithm上调用方法set_verbosity()来设置，该算法使用ihs构建。 详细程度大于1将产生一个日志，每次详细程度适应度评估都会有一个条目。- Returns
at each logged epoch, the values
Fevals,ppar,bw,dx,df,Violated,Viol. Norm,``ideal``Fevals(int), number of functions evaluation made.ppar(float), the pitch adjustment rate.bw(float), the distance bandwidth.dx(float), the population flatness evaluated as the distance between the decisions vector of the best and of the worst individual (or -1 in a multiobjective case).df(float), the population flatness evaluated as the distance between the fitness of the best and of the worst individual (or -1 in a multiobjective case).Violated(int), the number of constraints violated by the current decision vector.Viol. Norm(float), the constraints violation norm for the current decision vector.ideal_point(1D numpy array), the ideal point of the current population (cropped to max 5 dimensions only in the screen output)
- Return type
示例
>>> from pygmo import * >>> algo = algorithm(ihs(20000)) >>> algo.set_verbosity(2000) >>> prob = problem(hock_schittkowski_71()) >>> prob.c_tol = [1e-1]*2 >>> pop = population(prob, 20) >>> pop = algo.evolve(pop) Fevals: ppar: bw: dx: df: Violated: Viol. Norm: ideal1: 1 0.350032 0.999425 4.88642 14.0397 0 0 43.2982 2001 0.414032 0.316046 5.56101 25.7009 0 0 33.4251 4001 0.478032 0.0999425 5.036 26.9657 0 0 19.0052 6001 0.542032 0.0316046 3.77292 23.9992 0 0 19.0052 8001 0.606032 0.00999425 3.97937 16.0803 0 0 18.1803 10001 0.670032 0.00316046 1.15023 1.57947 0 0 17.8626 12001 0.734032 0.000999425 0.017882 0.0185438 0 0 17.5894 14001 0.798032 0.000316046 0.00531358 0.0074745 0 0 17.5795 16001 0.862032 9.99425e-05 0.00270865 0.00155563 0 0 17.5766 18001 0.926032 3.16046e-05 0.00186637 0.00167523 0 0 17.5748 >>> uda = algo.extract(ihs) >>> uda.get_log() [(1, 0.35003234534534, 0.9994245193792801, 4.886415773459253, 14.0397487316794, ...
另请参阅相关C++方法的文档
pagmo::ihs::get_log()。
- class pygmo.xnes(gen=1, eta_mu=- 1, eta_sigma=- 1, eta_b=- 1, sigma0=- 1, ftol=1e-6, xtol=1e-6, memory=False, force_bounds=False, seed=random)#
指数进化策略。
- Parameters
gen (
int) – 代数数量eta_mu (
float) – 均值更新的学习率（如果为-1，将自动选择为1）eta_sigma (
float) – 步长更新的学习率（如果为-1将自动选择）eta_b (
float) – 协方差矩阵更新的学习率（如果为-1将自动选择）sigma0 (
float) – 初始搜索宽度将为 sigma0 * (ub - lb)（如果为 -1 将自动选择为 1）ftol (
float) – 停止条件基于x的容差xtol (
float) – 停止标准基于f的容差memory (
bool) – 当为true时，适配的参数在连续调用evolve方法之间不会被重置force_bounds (
bool) – 当为true时，强制实施边界限制。适应度函数永远不会在边界之外被调用，但协方差矩阵适应机制会变差seed (
int) – 内部随机数生成器使用的种子（默认是随机的）
- Raises
OverflowError – 如果 gen 是负数或大于实现定义的值
ValueError – 如果 eta_mu, eta_sigma, eta_b, sigma0 不在 ]0,1] 或 -1 范围内
另请参阅C++类
pagmo::xnes的文档。- get_log()#
返回一个包含上次调用
evolve()期间记录的相关参数的日志。日志频率取决于详细程度参数（默认情况下不记录任何内容），可以通过在构造了xnes的algorithm上调用方法set_verbosity()来设置。详细程度为N意味着每N代记录一行日志。- Returns
at each logged epoch, the values
Gen,Fevals,Best,dx,df,sigma, where:Gen(int), generation numberFevals(int), number of functions evaluation madeBest(float), the best fitness function currently in the populationdx(float), the norm of the distance to the population mean of the mutant vectorsdf(float), the population flatness evaluated as the distance between the fitness of the best and of the worst individualsigma(float), the current step-size
- Return type
示例
>>> from pygmo import * >>> algo = algorithm(xnes(gen = 500)) >>> algo.set_verbosity(100) >>> prob = problem(rosenbrock(10)) >>> pop = population(prob, 20) >>> pop = algo.evolve(pop) Gen: Fevals: Best: dx: df: sigma: 1 0 173924 33.6872 3.06519e+06 0.5 101 2000 92.9612 0.583942 156.921 0.0382078 201 4000 8.79819 0.117574 5.101 0.0228353 301 6000 4.81377 0.0698366 1.34637 0.0297664 401 8000 1.04445 0.0568541 0.514459 0.0649836 Exit condition -- generations = 500 >>> uda = algo.extract(xnes) >>> uda.get_log() [(1, 0, 173924.2840042722, 33.68717961390855, 3065192.3843070837, 0.5), ...
另请参阅相关C++方法的文档
pagmo::xnes::get_log()。