问题类#

class pygmo.problem(udp=null_problem())#

问题类。

这个类表示一个通用的数学规划或进化优化问题，其形式为：

\[\begin{split}\begin{array}{rl} \mbox{find:} & \mathbf {lb} \le \mathbf x \le \mathbf{ub}\\ \mbox{to minimize: } & \mathbf f(\mathbf x, s) \in \mathbb R^{n_{obj}}\\ \mbox{subject to:} & \mathbf {c}_e(\mathbf x, s) = 0 \\ & \mathbf {c}_i(\mathbf x, s) \le 0 \end{array}\end{split}\]

其中 \(\mathbf x \in \mathbb R^{n_{cx}} \times \mathbb Z^{n_{ix}}\) 被称为决策向量或染色体，由 \(n_{cx}\) 个实数和 \(n_{ix}\) 个整数（全部表示为双精度浮点数）组成。问题的总维度由 \(n_x = n_{cx} + n_{ix}\) 表示。\(\mathbf{lb}, \mathbf{ub} \in \mathbb R^{n_{cx}} \times \mathbb Z^{n_{ix}}\) 是边界，\(\mathbf f: \mathbb R^{n_{cx}} \times \mathbb Z^{n_{ix}} \rightarrow \mathbb R^{n_{obj}}\) 定义了目标，\(\mathbf c_e: \mathbb R^{n_{cx}} \times \mathbb Z^{n_{ix}} \rightarrow \mathbb R^{n_{ec}}\) 是非线性等式约束，\(\mathbf c_i: \mathbb R^{n_{cx}} \times \mathbb Z^{n_{ix}} \rightarrow \mathbb R^{n_{ic}}\) 是非线性不等式约束。请注意，目标和约束也可能依赖于一个附加值 \(s\)，该值用于生成任意数量的随机变量的值。这也允许通过此类表示随机编程任务。所有约束的容差也被考虑，默认设置为零。可以通过 c_tol 属性进行修改。

为了在pygmo中定义一个优化问题，用户首先必须定义一个类，其方法描述问题的属性并允许计算目标函数、梯度、约束等。在pygmo中，我们将此类称为用户定义问题，简称UDP。一旦定义并实例化，UDP就可以用来构造这个类的实例，problem，它为优化问题提供了一个通用接口。

每个UDP必须至少实现以下两种方法：

def fitness(self, dv):
  ...
def get_bounds(self):
  ...

fitness() 方法预期返回输入决策向量的适应度（连接目标、等式约束和不等式约束），而 get_bounds() 方法预期返回问题的边界框 \((\mathbf{lb}, \mathbf{ub})\)，这也隐式地定义了问题的维度。UDP 的 fitness() 和 get_bounds() 方法可以通过相应的 pygmo.problem.fitness() 和 pygmo.problem.get_bounds() 方法访问（请参阅它们的文档以了解如何在 UDP 中实现这两个方法以及其他详细信息）。

上述两个必需的方法允许定义一个单一目标、确定性、无导数、无约束的优化问题。为了考虑更复杂的情况，UDP可以实现以下一个或多个方法：

def get_nobj(self):
  ...
def get_nec(self):
  ...
def get_nic(self):
  ...
def get_nix(self):
  ...
def batch_fitness(self, dvs):
  ...
def has_batch_fitness(self):
  ...
def has_gradient(self):
  ...
def gradient(self, dv):
  ...
def has_gradient_sparsity(self):
  ...
def gradient_sparsity(self):
  ...
def has_hessians(self):
  ...
def hessians(self, dv):
  ...
def has_hessians_sparsity(self):
  ...
def hessians_sparsity(self):
  ...
def has_set_seed(self):
  ...
def set_seed(self, s):
  ...
def get_name(self):
  ...
def get_extra_info(self):
  ...

有关如何在UDP中实现可选方法以及问题如何使用它们的详细信息，请参阅此类中相应方法的文档。请注意，暴露的C++问题也可以用作UDP，即使它们没有暴露上面列出的任何强制或可选方法（有关已在pygmo中编码的UDP的完整列表，请参见这里）。

这个类是C++类pagmo::problem的Python对应类。

Parameters

udp – 用户定义的问题，可以是C++或Python

Raises

NotImplementedError – 如果 udp 没有实现上述的强制方法
ValueError – 如果UDP的目标数量为零，目标数量、等式或不等式约束的数量大于实现定义的值，问题边界无效（例如，包含NaN，下界的维度与上界的维度不同等 - 注意允许无限边界），或者如果UDP的gradient_sparsity()和hessians_sparsity()方法未能通过基本健全性检查（例如，它们返回具有重复索引的向量，包含超出问题维度的索引等）
未指定 – 在构造过程中调用的UDP方法抛出的任何异常，UDP的深拷贝，底层C++类的构造函数，C++和Python之间的接口失败（例如，类型转换错误，函数签名不匹配等）

batch_fitness(dvs)#

该方法通过调用UDP的batch_fitness()方法，以批处理模式评估多个决策向量。UDP的batch_fitness()方法接受一批连续存储的决策向量dvs作为输入：对于一个维度为\(n\)的问题，dvs中的第一个决策向量占据索引范围\(\left[0, n\right)\)，第二个决策向量占据范围\(\left[n, 2n\right)\)，依此类推。返回值是计算输入决策向量适应度后得到的适应度向量fvs的批次。fvs也是连续存储的：对于一个适应度维度为\(f\)的问题，第一个适应度向量将占据索引范围\(\left[0, f\right)\)，第二个适应度向量将占据范围\(\left[f, 2f\right)\)，依此类推。

如果UDP提供了batch_fitness()方法，此方法将在进行完整性检查后将dvs转发给UDP的batch_fitness()方法。UDP的batch_fitness()方法的输出在返回之前也将被检查。如果UDP没有提供batch_fitness()方法，将会引发错误。

成功调用此方法将增加内部适应度评估计数器 (参见 get_fevals())。

UDP的batch_fitness()方法必须能够将决策向量作为一维NumPy数组输入，并且必须将适应度向量作为可迭代的Python对象（例如，一维NumPy数组、列表、元组等）返回。

Parameters

dvs (数组类对象) – 在批处理模式下要评估的决策向量（染色体）

Returns

dvs的适应度向量

Return type

一维NumPy浮点数数组

Raises

ValueError – 如果 dvs 和/或返回值与问题的属性不兼容
未指定 – 由UDP的batch_fitness()方法抛出的任何异常，或由C++和Python之间的交互失败引起的异常（例如，类型转换错误、函数签名不匹配等）。

property c_tol#

约束容差。

此属性包含一个float数组，用于检查约束可行性。数组的维度为\(n_{ec} + n_{ic}\)（即约束的总数），并且在问题构建时，数组被初始化为零。

此属性也可以通过标量而不是数组来设置。在这种情况下，所有的容差值将被设置为提供的标量值。

Returns

约束的容差

Return type

一维NumPy浮点数数组

Raises

ValueError – 如果设置此属性时，输入数组的大小与问题的约束数量不同，或者数组中的任何元素为负数或NaN
未指定 – 任何由C++和Python之间的失败引发的异常（例如，类型转换错误、函数签名不匹配等）。

示例

>>> from pygmo import problem, hock_schittkowski_71 as hs71
>>> prob = problem(hs71())
>>> prob.c_tol
array([0., 0.])
>>> prob.c_tol = [1, 2]
>>> prob.c_tol
array([1., 2.])
>>> prob.c_tol = .5
>>> prob.c_tol
array([0.5, 0.5])

extract(t)#

提取用户定义的问题。

此方法允许提取存储在此problem实例中的用户定义问题（UDP）的引用。此函数的行为取决于t的值（必须是一个type）以及内部UDP的类型：

如果UDP的类型是t，那么将返回对UDP的引用（这反映了相应的C++方法的行为 pagmo::problem::extract()），
如果 t 是 object 并且 UDP 是一个 Python 对象（而不是一个暴露的 C++ 问题），那么将返回对 UDP 的引用（这允许在不了解其类型的情况下提取 Python UDP），
否则，None 将被返回。

Parameters: t (type) – 要提取的用户定义问题的类型
Returns: 对内部用户定义问题的引用，如果提取失败则为None
Raises: TypeError – 如果 t 不是一个 type

示例

>>> import pygmo as pg
>>> p1 = pg.problem(pg.rosenbrock())
>>> p1.extract(pg.rosenbrock) 
<pygmo.core.rosenbrock at 0x7f56b870fd50>
>>> p1.extract(pg.ackley) is None
True
>>> class prob:
...     def fitness(self, x):
...         return [x[0]]
...     def get_bounds(self):
...         return ([0],[1])
>>> p2 = pg.problem(prob())
>>> p2.extract(object) 
<__main__.prob at 0x7f56a66b6588>
>>> p2.extract(prob) 
<__main__.prob at 0x7f56a66b6588>
>>> p2.extract(pg.rosenbrock) is None
True

feasibility_f(f)#

此方法将检查适应度向量f与c_tol返回的容差之间的可行性。

Parameters: f (类似数组的对象) – 适应度向量
Returns: True 如果适应度向量是可行的，False 否则
Return type: bool
Raises: ValueError – 如果 f 的大小与 get_nf() 的输出不相同

feasibility_x(x)#

此方法将检查决策向量x对应的适应度与c_tol返回的容差之间的可行性。

这将导致一次适应度评估。

Parameters: dv (数组类对象) – 一个决策向量
Returns: True 如果 x 导致可行的适应度，False 否则
Return type: bool
Raises: 未指定 – 由feasibility_f()或 fitness()抛出的任何异常

fitness(dv)#

健身。

此方法将调用UDP的fitness()方法来计算输入决策向量dv的适应度。UDP的fitness()方法的返回值预计具有\(n_{f} = n_{obj} + n_{ec} + n_{ic}\)的维度，并包含\(\mathbf f, \mathbf c_e\)和\(\mathbf c_i\)的串联值（按此顺序）。等式约束均假定为\(c_{e_i}(\mathbf x) = 0\)形式，而不等式约束假定为\(c_{i_i}(\mathbf x) <= 0\)形式，因此负值与满足的不等式相关联。

除了调用UDP的fitness()方法外，此方法还将对dv和返回的适应度向量进行合理性检查。成功调用此方法将增加内部适应度评估计数器（参见get_fevals()）。

UDP的fitness()方法必须能够将决策向量作为一维NumPy数组输入，并且必须返回适应度向量作为可迭代的Python对象（例如，一维NumPy数组、列表、元组等）。

Parameters

dv (数组类对象) – 要评估的决策向量（染色体）

Returns

dv的适应度

Return type

一维NumPy浮点数数组

Raises

ValueError – 如果dv的长度与get_nx()返回的值不同，或者返回的适应度向量的长度与get_nf()返回的值不同
未指定 – 由UDP的fitness()方法抛出的任何异常，或由C++和Python之间的交互失败引起的异常（例如，类型转换错误、函数签名不匹配等）。

get_bounds()#

盒子边界。

此方法将返回问题的边界框 \((\mathbf{lb}, \mathbf{ub})\)，如UDP的get_bounds()方法所返回的。边界中的无穷大是允许的。

UDP的get_bounds()方法必须返回一个包含2个元素的元组作为边界框，即下界向量和上界向量，这些向量必须表示为可迭代的Python对象（例如，一维NumPy数组、列表、元组等）。UDP返回的边界框在problem的构建过程中会被检查。

Returns: 一个由两个一维NumPy浮点数组组成的元组，表示问题的上下界
Return type: tuple
Raises: 未指定 – 由底层C++类的调用方法抛出的任何异常，或C++和Python之间的交互失败（例如，类型转换错误、函数签名不匹配等）

get_extra_info()#

问题的额外信息。

如果UDP提供了一个get_extra_info()方法，那么这个方法将返回其get_extra_info()方法的输出。否则，将返回一个空字符串。

Returns: 关于UDP的额外信息
Return type: str
Raises: 未指定 – 由UDP的get_extra_info()方法抛出的任何异常

get_fevals()#

适应度评估的次数。

每次成功完成对fitness()的调用时，内部计数器会增加一。计数器在问题构建时初始化为零，并且永远不会重置。复制操作也会复制计数器。

Returns: 成功调用fitness()的次数
Return type: int

get_gevals()#

梯度评估的次数。

每次成功完成对gradient()的调用时，内部计数器会增加一。计数器在问题构建时初始化为零，并且永远不会重置。复制操作也会复制计数器。

Returns: 成功调用gradient()的次数
Return type: int

get_hevals()#

Hessian矩阵评估的次数。

每次成功调用hessians()时，内部计数器会增加一。计数器在问题构建时初始化为零，并且永远不会重置。复制操作也会复制计数器。

Returns: 成功调用hessians()的次数
Return type: int

get_lb()#

下界框。

此方法将返回此问题的下界框。有关如何确定边界的详细说明，请参见get_bounds()。

Returns: 表示此问题的下界框的数组
Return type: 一维NumPy浮点数数组
Raises: 未指定 – 由底层C++类的调用方法抛出的任何异常，或C++和Python之间的交互失败（例如，类型转换错误、函数签名不匹配等）

get_name()#

问题的名称。

如果UDP提供了一个get_name()方法，那么这个方法将返回其get_name()方法的输出。否则，将返回一个基于UDP类型的实现定义的名称。

Returns: 问题名称
Return type: str

get_nc()#

约束的总数。

此方法将返回get_nic()和get_nec()输出的总和（即约束的总数）。

Returns: 问题的约束总数
Return type: int

get_ncx()#

问题的连续维度。

此方法将返回\(n_{cx}\)，即问题的连续维度。

Returns: 问题的连续维度
Return type: int

get_nec()#

等式约束的数量。

此方法将返回\(n_{ec}\)，即问题的等式约束数量。

可选的 get_nec() 方法必须返回等式约束的数量作为 int。如果 UDP 没有实现 get_nec() 方法，则假定为零个等式约束。 UDP 返回的等式约束数量在 problem 的构建时进行检查。

Returns: 问题的等式约束数量
Return type: int

get_nf()#

适应度的维度。

此方法将返回\(n_{f}\)，即适应度的维度，它是\(n_{obj}\)、\(n_{ec}\)和\(n_{ic}\)的总和。

Returns: 适应度的维度
Return type: int

get_nic()#

不等式约束的数量。

此方法将返回\(n_{ic}\)，即问题的不等式约束数量。

可选的 get_nic() 方法必须返回不等式约束的数量作为 int。如果 UDP 没有实现 get_nic() 方法，则假定为零个不等式约束。 UDP 返回的不等式约束数量在 problem 的构建时进行检查。

Returns: 问题的不等式约束数量
Return type: int

get_nix()#

问题的整数维度。

此方法将返回\(n_{ix}\)，问题的整数维度。

可选的 get_nix() 方法必须返回问题的整数维度作为 int。如果 UDP 没有实现 get_nix() 方法，则假定整数维度为零。 UDP 返回的整数维度在构建 problem 时进行检查。

Returns: 问题的整数维度
Return type: int

get_nobj()#

目标数量。

此方法将返回\(n_{obj}\)，即问题的目标数量。

可选的 get_nobj() 方法必须返回目标的数量作为 int。如果 UDP 没有实现 get_nobj() 方法，将假定为单目标优化问题。 UDP 返回的目标数量在构建 problem 时会被检查。

Returns: 问题的目标数量
Return type: int

get_nx()#

问题的维度。

此方法将返回\(n_{x}\)，即由get_bounds()返回的边界长度所确定的问题维度。

Returns: 问题的维度
Return type: int

get_thread_safety()#

问题的线程安全级别。

此方法将返回一个枚举值 pygmo.thread_safety，该值指示UDP的线程安全级别。与C++不同，在Python中无法在UDP中重新实现此方法。也就是说，对于C++ UDP，返回值将是UDP的 get_thread_safety() 方法返回的值。对于Python UDP，返回值将无条件为 none。

Returns: UDP的线程安全级别
Return type: 一个值为 pygmo.thread_safety

get_ub()#

上箱边界。

此方法将返回此问题的上界框。有关如何确定边界的详细说明，请参见get_bounds()。

Returns: 表示此问题的上界框的数组
Return type: 一维NumPy浮点数数组
Raises: 未指定 – 由底层C++类的调用方法抛出的任何异常，或C++和Python之间的交互失败（例如，类型转换错误、函数签名不匹配等）

gradient(dv)#

梯度。

该方法将通过调用UDP的gradient()方法来计算输入决策向量dv的梯度。UDP的gradient()方法必须返回梯度的稀疏表示：梯度向量的第\(k\)项应包含\(\frac{\partial f_i}{\partial x_j}\)，其中对\((i,j)\)是稀疏模式（索引对集合）的第\(k\)个元素，如gradient_sparsity()所返回的。

如果UDP提供了一个gradient()方法，此方法将在进行完整性检查后将dv转发给UDP的gradient()方法。UDP的gradient()方法的输出在返回之前也会被检查。如果UDP没有提供gradient()方法，将会引发错误。此方法的成功调用将增加内部梯度评估计数器（参见get_gevals()）。

gradient() 方法必须能够将决策向量作为一维NumPy数组输入，并且必须返回梯度向量作为可迭代的Python对象（例如，一维NumPy数组、列表、元组等）。

Parameters

dv (数组类对象) – 将计算其梯度的决策向量

Returns

dv 的梯度

Return type

一维NumPy浮点数数组

Raises

ValueError – 如果dv的长度与get_nx()返回的值不同，或者返回的梯度向量与gradient_sparsity()返回的向量大小不同
NotImplementedError – 如果UDP没有提供gradient()方法
未指定 – 由UDP的gradient()方法抛出的任何异常，或由C++和Python之间的交互失败引起的异常（例如，类型转换错误、函数签名不匹配等）。

gradient_sparsity()#

梯度稀疏模式。

此方法将返回问题的梯度稀疏模式。梯度稀疏模式是\(g_{ij} = \frac{\partial f_i}{\partial x_j}\)非零元素的索引\((i,j)\)的字典排序集合。

如果 has_gradient_sparsity() 返回 True，那么 UDP 的 gradient_sparsity() 方法将被调用，并返回其结果（经过完整性检查）。否则，将假定为密集模式，返回的向量将是 \(((0,0),(0,1), ... (0,n_x-1), ...(n_f-1,n_x-1))\)。

UDP的gradient_sparsity()方法必须返回一个2D的NumPy整数数组，或者任何类型的可迭代Python对象。具体来说：

如果返回值是一个NumPy数组，其形状必须为\((n,2)\)（其中\(n \geq 0\)），
如果返回值是一个可迭代的Python对象，那么它的元素也必须是可迭代的Python对象，每个元素必须恰好包含2个元素，表示索引\((i,j)\)。

Returns

梯度稀疏模式

Return type

2D Numpy 整数数组

Raises

ValueError – 如果UDP返回的NumPy数组不满足上述要求（例如，无效的形状、维度等），返回的可迭代Python对象中至少有一个元素不包含恰好2个元素的集合，或者UDP返回的稀疏模式无效（特别是，如果不是严格按字典顺序排序，或者模式中的索引与问题的属性不兼容，或者返回的模式的大小与构造时记录的大小不同）
OverflowError – 如果UDP返回的NumPy数组包含负值或超出实现定义范围的整数值
未指定 – 由底层C++函数抛出的任何异常，NumPy C API中的PyArray_FROM_OTF()函数，或C++与Python之间的交互失败（例如，类型转换错误，函数签名不匹配等）

has_batch_fitness()#

检查UDP中是否可用batch_fitness()方法。

如果UDP中存在batch_fitness()方法，则此方法将返回True，否则返回False。

batch_fitness() 方法的可用性确定如下：

如果UDP没有提供batch_fitness()方法，那么这个方法将总是返回False；
如果UDP提供了一个batch_fitness()方法，但它没有提供一个has_batch_fitness()方法，那么这个方法将始终返回True；
如果UDP同时提供了batch_fitness()和has_batch_fitness()方法，那么此方法将返回UDP的has_batch_fitness()方法的输出。

可选的 has_batch_fitness() 方法必须返回一个 bool。有关如何实现 UDP 的 batch_fitness() 方法的信息，请参阅 batch_fitness()。

Returns: 一个标志，表示UDP中batch_fitness()方法的可用性
Return type: bool

has_gradient()#

检查梯度是否在UDP中可用。

如果梯度在UDP中可用，此方法将返回True，否则返回False。

梯度的可用性确定如下：

如果UDP没有提供gradient()方法，那么这个方法将总是返回False；
如果UDP提供了一个gradient()方法但没有提供has_gradient()方法，那么这个方法将总是返回True；
如果UDP提供了gradient()和has_gradient()方法，那么这个方法将返回UDP的has_gradient()方法的输出。

可选的 has_gradient() 方法必须返回一个 bool。有关如何实现 UDP 的 gradient() 方法的信息，请参阅 gradient()。

Returns: 一个标志，表示UDP中梯度的可用性
Return type: bool

has_gradient_sparsity()#

检查UDP中是否提供了梯度稀疏性。

如果梯度稀疏性在UDP中可用，此方法将返回True，否则返回False。

梯度稀疏性的可用性确定如下：

如果UDP没有提供gradient_sparsity()方法，那么这个方法将总是返回False;
如果UDP提供了一个gradient_sparsity()方法，但没有提供has_gradient_sparsity()方法，那么这个方法将始终返回True；
如果UDP同时提供了gradient_sparsity()方法和has_gradient_sparsity()方法，那么这个方法将返回UDP的has_gradient_sparsity()方法的输出。

可选的 has_gradient_sparsity() 方法必须返回一个 bool。有关如何实现 UDP 的 gradient_sparsity() 方法的信息，请参阅 gradient_sparsity()。

注意

无论此方法返回什么，gradient_sparsity() 方法将始终返回一个稀疏模式：如果UDP不提供梯度稀疏性，pygmo将假设梯度的稀疏模式是密集的。有关更多详细信息，请参阅gradient_sparsity()。

Returns: 一个标志，表示UDP中梯度稀疏性的可用性
Return type: bool

has_hessians()#

检查Hessians是否在UDP中可用。

如果Hessians在UDP中可用，此方法将返回True，否则返回False。

Hessians 的可用性确定如下：

如果UDP没有提供hessians()方法，那么这个方法将总是返回False；
如果UDP提供了一个hessians()方法，但没有提供一个has_hessians()方法，那么这个方法将始终返回True；
如果UDP同时提供了hessians()和has_hessians()方法，那么这个方法将返回UDP的has_hessians()方法的输出。

可选的 has_hessians() 方法必须返回一个 bool。有关如何实现 UDP 的 hessians() 方法的信息，请参阅 hessians()。

Returns: 一个标志，表示UDP中hessians的可用性
Return type: bool

has_hessians_sparsity()#

检查UDP中是否可用hessians稀疏性。

如果UDP中Hessian稀疏性可用，此方法将返回True，否则返回False。

Hessians稀疏性的可用性确定如下：

如果UDP没有提供hessians_sparsity()方法，那么这个方法将总是返回False;
如果UDP提供了一个hessians_sparsity()方法，但没有提供一个has_hessians_sparsity()方法，那么这个方法将始终返回True；
如果UDP提供了hessians_sparsity()方法和has_hessians_sparsity()方法，那么这个方法将返回UDP的has_hessians_sparsity()方法的输出。

可选的 has_hessians_sparsity() 方法必须返回一个 bool。有关如何实现 UDP 的 hessians_sparsity() 方法的信息，请参阅 hessians_sparsity()。

注意

无论此方法返回什么，hessians_sparsity() 方法将始终返回一个稀疏模式：如果UDP不提供hessians稀疏性，pygmo将假设hessians的稀疏模式是密集的。有关更多详细信息，请参阅hessians_sparsity()。

Returns: 一个标志，表示UDP中hessians稀疏性的可用性
Return type: bool

has_set_seed()#

检查UDP中是否有set_seed()方法可用。

如果UDP中存在set_seed()方法，则此方法将返回True，否则返回False。

set_seed() 方法的可用性确定如下：

如果UDP没有提供set_seed()方法，那么这个方法将总是返回False；
如果UDP提供了一个set_seed()方法，但没有提供一个has_set_seed()方法，那么这个方法将始终返回True；
如果UDP提供了set_seed()和has_set_seed()方法，那么这个方法将返回UDP的has_set_seed()方法的输出。

可选的 has_set_seed() 方法必须返回一个 bool。有关如何实现 UDP 的 set_seed() 方法的信息，请参阅 set_seed()。

Returns: 一个标志，表示UDP中set_seed()方法的可用性
Return type: bool

hessians(dv)#

海森矩阵。

该方法将通过调用UDP的hessians()方法来计算输入决策向量dv的Hessian矩阵。UDP的hessians()方法必须返回Hessian矩阵的稀疏表示：返回向量的第\(l\)个元素包含\(h^l_{ij} = \frac{\partial f^2_l}{\partial x_i\partial x_j}\)，顺序由Hessian稀疏模式（一个索引对\((i,j)\)的向量）的第\(l\)个元素指定，如hessians_sparsity()所返回的。由于Hessian矩阵是对称的，其稀疏表示仅包含下三角元素。

如果UDP提供了hessians()方法，此方法将在进行完整性检查后将dv转发给UDP的hessians()方法。UDP的hessians()方法的输出在返回之前也会被检查。如果UDP没有提供hessians()方法，将会引发错误。此方法的成功调用将增加内部hessians评估计数器（参见get_hevals()）。

UDP的hessians()方法必须能够将决策向量作为一维NumPy数组作为输入，并且必须将hessians向量作为可迭代的Python对象（例如，列表、元组等）返回。

Parameters

dv (数组类对象) – 将计算其Hessian矩阵的决策向量

Returns

dv 的 Hessian 矩阵

Return type

list 一维 NumPy 浮点数组

Raises

ValueError – 如果dv的长度与get_nx()返回的值不同，或者返回的hessians的长度与相应的hessians稀疏模式维度不匹配，或者返回值的大小不等于适应度维度
NotImplementedError – 如果UDP没有提供hessians()方法
未指定 – 由UDP的hessians()方法抛出的任何异常，或由C++和Python之间的交互失败引起的异常（例如，类型转换错误、函数签名不匹配等）。

hessians_sparsity()#

Hessian矩阵的稀疏模式。

此方法将返回问题的海森矩阵稀疏模式。海森矩阵稀疏模式的每个组件 \(l\) 是一个按字典顺序排序的索引集合 \((i,j)\)，这些索引对应于非零元素 \(h^l_{ij} = \frac{\partial f^l}{\partial x_i\partial x_j}\)。由于海森矩阵是对称的，只允许下三角元素。

如果 has_hessians_sparsity() 返回 True，那么 UDP 的 hessians_sparsity() 方法将被调用，并返回其结果（经过完整性检查）。否则，将假定为密集模式，并返回包含 \(((0,0),(1,0), (1,1), (2,0) ... (n_x-1,n_x-1))\) 的 \(n_f\) 稀疏模式。

UDP的hessians_sparsity()方法必须返回一个可迭代的Python对象。返回对象的每个元素将被解释为稀疏模式，其方式与gradient_sparsity()中描述的相同。具体来说：

如果元素是NumPy数组，其形状必须为\((n,2)\)（其中\(n \geq 0\)），
如果元素本身是一个可迭代的Python对象，那么它的元素也必须是可迭代的Python对象，每个元素必须恰好包含2个元素，表示索引\((i,j)\)。

Returns

海森矩阵的稀疏模式

Return type

list 的二维Numpy整数数组

Raises

ValueError – 如果UDP返回的NumPy数组不满足上述要求（例如，无效的形状、维度等），返回的可迭代Python对象中至少有一个元素不包含恰好2个元素的集合，或者如果UDP返回的稀疏模式无效（特别是，如果不是严格按字典顺序排序，如果模式中的索引与问题的属性不兼容，或者如果模式的大小与构建时记录的大小不同）
OverflowError – 如果UDP返回的NumPy数组包含负值或超出实现定义范围的整数值
未指定 – 由底层C++函数抛出的任何异常，NumPy C API中的PyArray_FROM_OTF()函数，或C++与Python之间的交互失败（例如，类型转换错误，函数签名不匹配等）

increment_fevals(n)#

增加适应度评估的次数。

版本2.13中的新功能。

此方法将增加适应度评估的内部计数器n次。

Parameters: n (int) – 适应度评估的内部计数器将增加的数值
Raises: 未指定 – 任何由C++和Python之间的失败引发的异常（例如，类型转换错误、函数签名不匹配等）。

is_(t)#

检查用户定义问题的类型。

如果extract(t)返回None，则此方法返回False，否则返回True。

Parameters: t (type) – 将与UDP类型进行比较的类型
Returns: UDP 是否为 t 类型
Return type: bool
Raises: 未指定 – 由extract()抛出的任何异常

is_stochastic()#: has_set_seed() 的别名。

set_seed(seed)#

为随机变量设置种子。

此方法将设置用于适应度函数中的种子，以实例化所有随机变量。如果UDP提供了set_seed()方法，则将调用其set_seed()方法。否则，将引发错误。seed参数必须为非负数。

UDP的set_seed()方法必须能够接受int作为输入参数。

Parameters

seed (int) – 所需的种子值

Raises

NotImplementedError – 如果UDP没有提供set_seed()方法
OverflowError – 如果 seed 为负数
未指定 – 由UDP的set_seed()方法引发的任何异常或C++与Python之间的交互失败（例如，类型转换错误、函数签名不匹配等）