贝叶斯优化之采集函数 0基础学习
写在前面：什么是贝叶斯优化
参考这里
主要包含两个部分
-
一个代理模型（surrogate model），用于对目标函数进行建模。代理模型通常有确定的公式或者能计算梯度，又或者有已知的凹凸性、线性等特性，总之就是更容易用于优化。更泛化地讲，其实它就是一个学习模型，输入是所有观测到的函数值点，训练后可以在给定任意x的情况下给出对f(x)的估计。
-
一个优化策略（optimization strategy），决定下一个采样点的位置，即下一步应在哪个输入x
处观测函数值f(x)。通常它是通过采集函数（acquisition function） 来实现的：
采集函数通常是一个由代理模型推出的函数，它的输入是可行集（feasible set）A上的任意值，输出值衡量了每个输入x有多值得被观测。通常会从以下两方面考虑：- 有多大的可能性在x处取得最优值
- 评估x是否能减少贝叶斯统计模型的不确定性
采集函数通常也是容易求最优值的函数（例如：有公式/能算梯度等），下一个采样点就是可行集上的最大值点，即使采集函数的取最大值的点。
本文主要学习采集函数，模型代码参考SCOOT(WWW2025 oral)中hebo/acqusitions库的代码实现。
代理模型内容见此
HEBO的简要介绍
SCOOT代码大部分都是基于HEBO（异质方差进化贝叶斯优化）算法实现，这里先简要介绍下，具体见https://github.com/huawei-noah/HEBO
背景
- 建模假设
使用代理模型来近似黑盒函数问题。常见的代理模型是高斯过程回归模型（Gaussian processes，GPs)。GPs模型本身是同方差的（Heteroscedastic），但其实际建模的问题是带异质方差噪音，同时同方差的GPs模型不能处理非平稳的评估点集，这种现象在机器学习超参数优化中尤为常见。 - 采集函数和优化器假设
在采集函数阶段，通常是最大化采集函数并输出下一个候选点。这一过程将引入额外的限制和假设。如假设黑盒函数中只包含连续变量，采取一阶或二阶（如LBFGS，ADAM）来求解，而忽略了超参数优化中包含的离散变量（如深度网络中的隐层大小）。另外在整一个贝叶斯优化框架中采集函数只选择一种，忽略了多个采集函数组合的情况。
问题及回答
问题1：超参数优化任务是平稳的吗？
回答：即使是简单的机器学习任务也显示出极大的非平稳性（ non-stationarity）
问题2：超参数优化任务是同质的吗？
回答：即使是简单的机器学习任务也显示出极大的异方差性（heteroscedasticity）
问题3：在超参数优化中，不同采集函数输出的结果是否是冲突的呢？
回答：没有“一招鲜吃遍天”的方法。不同采集函数通常是冲突，经常会输出相反的候选点
总结
- 针对不平稳性，对输入做转化(Transformation)
- 针对异质方差，对输出做转化(Transformation)
- 不同采集函数在不同参数设置下，其对应的采集函数值相互冲突。 对此，作者从如下两方面进行优化：
- 带鲁棒性的采集函数；
- 多目标采集函数。
整体主要由如下部分组成：
伪随机序列生成，具体可用参考笔者《超参数优化(三): 实验设计》部分
对X进行变换
对y进行变换
调用GPs模型，进行训练建模
GPs模型输出的最优候选点
构建采集函数
多目标采集函数优化
输出最优候选点
本文介绍的HEBO方法，在2020 BBO大赛和QQ浏览器2021AI算法大赛中表现都非常优异。HEBO算法框架仍然是贝叶斯优化（Bayesian Optimisation）。作者通过分析经典贝叶斯优化的数据输入、数据输出、代理模型和采集函数存在的问题和局限性，对每一步的问题都做了相应的优化：
对数据输入、数据输出进行变换校准；
将数据变换校准和GPs核函数联合在一起优化；
引入多目标采集函数，进行更鲁棒的探索（HEBO方法最大亮点)。
采集函数
从SCOOT的代码结构上来看，使用了两个优化器
当优化目标是单目标时使用的是HEBOConstr，采集函数使用的MACEConstr
当优化目标是多目标时使用的是GeneralBO，采集函数使用的GeneralAcq
MACEConstr
class MACEConstr(Acquisition):
def __init__(self, model, best_y, num_model_constr, y_thres, **conf):
# 调用父类 Acquisition 的初始化方法
super().__init__(model, **conf)
# 设置LCB中的探索系数kappa，默认值为2.0
self.kappa = conf.get('kappa', 2.0)
# 设置数值稳定性参数，避免除零错误，默认1e-4
self.eps = conf.get('eps', 1e-4)
# 设置硬约束数量，默认3个
self._num_hard_constr = conf.get('num_hard_constr', 3)
# 设置隐藏约束数量，默认1个
self._num_hidden_constr = conf.get('num_hidden_constr', 1)
# 获取随机森林模型及阈值，用于评估隐藏约束
self.rf_with_thres = conf.get('rf_with_thres', None)
# 设置最大序列长度，用于硬约束检查，默认12
self.max_sequence_length = conf.get('max_sequence_length', 12)
# 获取搜索空间定义
self.space = conf.get('space', None)
# 设置当前最佳目标值tau，用于EI和PI计算
self.tau = best_y
# 设置约束阈值，约束函数需要小于该阈值
self.y_thres = y_thres
# 设置模型约束数量（通过高斯过程建模的约束）
self._num_model_constr= num_model_constr
# 如果没有定义搜索空间，则禁用硬约束和隐藏约束
if not self.space:
self._num_hard_constr = 0
self._num_hidden_constr = 0
# 如果有隐藏约束，必须提供随机森林模型和阈值
if self._num_hidden_constr > 0:
assert isinstance(self.rf_with_thres, tuple), f'num_hiddent_constr is {self._num_hidden_constr}, the rf model and corresponding threshold should be passed'
@property
def num_obj(self):
"""返回目标函数数量，固定为3（LCB, EI, PI三个采集准则）"""
return 3
@property
def num_model_constr(self) -> int:
"""返回模型约束数量的属性"""
return self._num_model_constr
@property
def num_hidden_constr(self) -> int:
"""返回隐藏约束数量的属性"""
return self._num_hidden_constr
@property
def num_constr(self) -> int:
"""返回总约束数量的属性（模型约束+硬约束+隐藏约束）"""
return self._num_model_constr + self._num_hard_constr + self._num_hidden_constr
@property
def num_hard_constr(self) -> int:
"""返回硬约束数量的属性"""
return self._num_hard_constr
def eval(self, x : torch.FloatTensor, xe : torch.LongTensor) -> torch.FloatTensor:
"""
采集函数评估方法
最小化三个目标：(-1 * EI的负对数, -1 * PI的负对数, LCB)
即同时优化三种采集准则：EI、PI和LCB
"""
# 不计算梯度，提高计算效率
with torch.no_grad():
# 使用高斯过程模型预测均值和方差
py, ps2 = self.model.predict(x, xe)
### 目标函数部分：计算三种采集准则 ###
# 提取目标函数的预测（第一列）
py_obj = py[:,:1]
# 提取目标函数的方差（第一列）
ps2_obj = ps2[:, :1]
# 计算噪声标准差，乘以sqrt(2)用于EI/PI计算
noise = np.sqrt(2.0) * self.model.noise.sqrt()[0]
# 计算目标函数的标准差，确保数值稳定性
ps_obj = ps2_obj.sqrt().clamp(min = torch.finfo(ps2_obj.dtype).eps)
# 计算LCB（Lower Confidence Bound）：均值 - kappa * 标准差
lcb_obj = (py_obj + noise * torch.randn(py_obj.shape)) - self.kappa * ps_obj
# 计算标准化改进量：(当前最佳值 - 预测值) / 标准差
normed = ((self.tau - self.eps - py_obj - noise * torch.randn(py_obj.shape)) / ps_obj)
# 创建标准正态分布对象
dist = Normal(0., 1.)
# 计算标准正态分布在normed处的对数概率密度
log_phi = dist.log_prob(normed)
# 计算标准正态分布在normed处的累积分布函数
Phi = dist.cdf(normed)
# 计算改进概率PI：P(f(x) < tau)
PI = Phi
# 计算期望改进EI：E[max(tau - f(x), 0)]
EI = ps_obj * (Phi * normed + log_phi.exp())
# EI的对数近似公式，用于数值不稳定情况
logEIapp = ps_obj.log() - 0.5 * normed**2 - (normed**2 - 1).log()
# PI的对数近似公式，用于数值不稳定情况
logPIapp = -0.5 * normed**2 - torch.log(-1 * normed) - torch.log(torch.sqrt(torch.tensor(2 * np.pi)))
# 判断哪些点需要使用近似公式：
# 当normed > -6 且 EI和PI的对数有限时使用精确计算，否则使用近似
use_app = ~((normed > -6) & torch.isfinite(EI.log()) & torch.isfinite(PI.log())).reshape(-1)
# 初始化输出张量，3列对应3个采集准则
out = torch.zeros(x.shape[0], 3)
# 第一列：LCB目标（探索性）
out[:, 0] = lcb_obj.reshape(-1)
# 第二列：EI准则（使用近似或精确计算）
out[:, 1][use_app] = -1 * logEIapp[use_app].reshape(-1) # 使用近似
out[:, 1][~use_app] = -1 * EI[~use_app].log().reshape(-1) # 使用精确
# 第三列：PI准则（使用近似或精确计算）
out[:, 2][use_app] = -1 * logPIapp[use_app].reshape(-1) # 使用近似
out[:, 2][~use_app] = -1 * PI[~use_app].log().reshape(-1) # 使用精确
### 模型约束部分 ###
if self.y_thres is not None:
# 提取约束函数的预测（第1列之后的所有列）
py_constr = py[:, 1:]
# 提取约束函数的方差
ps2_constr = ps2[:, 1:]
# 计算约束函数的标准差
ps_constr = ps2_constr.sqrt().clamp(min = torch.finfo(ps2_constr.dtype).eps)
# 计算约束违反程度：预测值 + kappa*标准差 - 阈值
# 如果结果>0表示可能违反约束
out_model_constr = (py_constr + noise * torch.randn(py_constr.shape)) + self.kappa * ps_constr - self.y_thres
else:
# 没有模型约束时返回空张量
out_model_constr = torch.zeros([out.size()[0], 0])
# 获取硬约束违反程度（基于先验知识的约束）
out_hard_constr = get_hard_constr(x, self.max_sequence_length,
self.num_hard_constr, py, self.space)
# 获取隐藏约束违反程度（基于随机森林模型的约束）
out_hidden_constr = get_hidden_constr(x, xe, self.rf_with_thres,
self.num_hidden_constr, py, self.space)
# 合并所有输出：3个采集准则目标 + 模型约束 + 硬约束 + 隐藏约束
return torch.concat([out, out_model_constr, out_hard_constr, out_hidden_constr], dim=1)
GeneralAcq
class GeneralAcq(Acquisition):
def __init__(self, model, num_obj, num_model_constr, **conf):
# 调用父类 Acquisition 的初始化方法
super().__init__(model, **conf)
# 设置目标函数数量
self._num_obj = num_obj
# 设置模型约束数量（通过高斯过程建模的约束）
self._num_model_constr = num_model_constr
# 从配置中获取硬约束数量，默认为3
self._num_hard_constr = conf.get('num_hard_constr', 3)
# 从配置中获取隐藏约束数量，默认为1
self._num_hidden_constr = conf.get('num_hidden_constr', 1)
# 获取随机森林模型及阈值，用于隐藏约束评估
self.rf_with_thres = conf.get('rf_with_thres', None)
# 获取搜索空间定义
self.space = conf.get('space', None)
# 获取目标函数的kappa参数（探索系数），默认为2.0
self.kappa = conf.get('kappa', 2.0)
# 获取约束函数的c_kappa参数（约束探索系数），默认为0
self.c_kappa = conf.get('c_kappa', 0.)
# 是否在预测时添加噪声，默认为True
self.use_noise = conf.get('use_noise', True)
# 最大序列长度，用于硬约束检查，默认为12
self.max_sequence_length = conf.get('max_sequence_length', 12)
# 如果没有定义搜索空间，则禁用硬约束和隐藏约束
if not self.space:
self._num_hard_constr = 0
self._num_hidden_constr = 0
# 验证模型输出维度等于目标数加模型约束数
assert self.model.num_out == self.num_obj + self.num_model_constr
# 验证至少有一个目标函数
assert self.num_obj >= 1
# 如果有隐藏约束，必须提供随机森林模型和阈值
if self._num_hidden_constr > 0:
assert isinstance(self.rf_with_thres, tuple), f'num_hiddent_constr is {self._num_hidden_constr}, the rf model and corresponding threshold should be passed'
@property
def num_obj(self) -> int:
"""返回目标函数数量的属性"""
return self._num_obj
@property
def num_model_constr(self) -> int:
"""返回模型约束数量的属性"""
return self._num_model_constr
@property
def num_hidden_constr(self) -> int:
"""返回隐藏约束数量的属性"""
return self._num_hidden_constr
@property
def num_constr(self) -> int:
"""返回总约束数量的属性（模型约束+硬约束+隐藏约束）"""
return self._num_model_constr+self._num_hard_constr + self._num_hidden_constr
@property
def num_hard_constr(self) -> int:
"""返回硬约束数量的属性"""
return self._num_hard_constr
def eval(self, x : torch.FloatTensor, xe : torch.LongTensor) -> torch.FloatTensor:
"""
采集函数评估方法，处理一般约束多目标优化问题
假设有 $om$ 个目标和 $cn$ 个约束，问题应被转化为：
最小化 (o1, o2, ..., om)
满足 c1 < 0,
c2 < 0,
...
cb_cn < 0
在这个 GeneralAcq 采集函数中，我们计算目标和约束的下置信界，
并解决以下问题：
最小化 (lcb_o1, lcb_o2, ..., lcb_om)
满足 lcb_c1 < 0,
lcb_c2 < 0,
...
lcb_cn < 0
"""
# 不计算梯度，提高计算效率
with torch.no_grad():
# 使用模型预测均值和方差
py, ps2 = self.model.predict(x, xe)
# 计算标准差，并确保数值稳定性（避免除零错误）
ps = ps2.sqrt().clamp(min = torch.finfo(ps2.dtype).eps)
# 如果启用噪声，在预测值上添加高斯噪声
if self.use_noise:
noise = self.model.noise.sqrt() # 获取噪声标准差
py += noise * torch.randn(py.shape) # 添加随机噪声
# 初始化输出张量，形状与预测值相同
out = torch.ones(py.shape)
# 计算目标函数的下置信界（LCB）
# 对于最小化问题，LCB = 均值 - kappa * 标准差
out[:, :self.num_obj] = py[:, :self.num_obj] - self.kappa * ps[:, :self.num_obj]
# 计算约束函数的下置信界
# 对于约束c<0，LCB = 均值 - c_kappa * 标准差
out[:, self.num_obj:] = py[:, self.num_obj:] - self.c_kappa * ps[:, self.num_obj:]
# 获取硬约束违反程度（基于先验知识的约束）
out_hard_constr = get_hard_constr(x, self.max_sequence_length,
self.num_hard_constr, py, self.space)
# 获取隐藏约束违反程度（基于随机森林模型的约束）
out_hidden_constr = get_hidden_constr(x, xe, self.rf_with_thres,
self.num_hidden_constr, py, self.space)
# 合并所有输出：目标LCB + 模型约束LCB + 硬约束 + 隐藏约束
return torch.concat([out, out_hard_constr, out_hidden_constr], dim=1)
区别
在单目标问题中，没有一种采集准则在任何情况下都是最优的：
EI：在中等不确定性下表现好
PI：在低不确定性下偏向利用
LCB/UCB：在高不确定性下偏向探索
MACE的解决方案则是同时优化三种准则，让算法自动选择平衡：minimize [LCB, -log(EI), -log(PI)]（间接转化为了一个多目标优化）
多目标问题本身就有多个需要权衡的目标，引入多种采集准则会使问题过于复杂，而且LCB可以很自然地扩展到多目标情况，对于M个目标，需要计算M次EI和M次PI，计算量随目标数线性增长，且数值稳定性问题更严重
优化器
介绍下HEBOConstr和GeneralBO是怎么用这些acq的
HEBOConstr
class HEBOConstr(AbstractOptimizer):
# 类属性：声明支持的优化特性
support_parallel_opt = True # 支持并行优化，可同时评估多个候选点
support_combinatorial = True # 支持组合优化，可处理离散和连续混合参数
support_contextual = True # 支持上下文优化，可处理固定参数约束
def __init__(self,
space,
num_model_constr,
y_thres = None,
model_name = 'multi_task',
base_model_name='gpy',
rand_sample = None,
acq_cls = MACEConstr,
es = 'nsga2',
model_config = None,
scramble_seed: Optional[int] = None,
num_hard_constr: Optional[int] = None,
num_hidden_constr: Optional[int] = 1,
max_sequence_length: Optional[int] = 12): # 最大序列长度默认12，对应2^12=4096
"""
构造函数：初始化约束贝叶斯优化器
参数说明：
space: 搜索空间定义，包含参数类型、范围等信息
num_model_constr: 模型约束数量，通过高斯过程建模的约束个数
y_thres: 约束阈值，约束函数需要小于该阈值才可行
model_name: 代理模型名称，默认'multi_task'多任务模型
base_model_name: 基础模型类型，默认'gpy'使用GPy库的高斯过程
rand_sample: 随机采样迭代次数，在开始阶段使用随机探索
acq_cls: 采集函数类，默认MACEConstr用于约束优化的多准则采集
es: 进化算法类型，默认'nsga2'用于多目标优化
model_config: 模型配置字典，可自定义模型参数
scramble_seed: Sobol序列随机种子，用于初始点采样的可重复性
num_hard_constr: 硬约束数量，问题固有的不可违反约束
num_hidden_constr: 隐藏约束数量，通过随机森林等模型学习的约束
max_sequence_length: 最大序列长度，用于硬约束检查
"""
# 调用父类AbstractOptimizer的构造函数，初始化基础功能
super().__init__(space)
# 存储搜索空间对象，用于参数转换和边界检查
self.space = space
# 设置进化算法类型，用于优化采集函数寻找候选点
self.es = es
# 初始化观测数据存储：X存储历史参数配置，y存储对应的目标值和约束值
# X是DataFrame，列名为参数名称；y是numpy数组，第一列是目标值，后面是约束值
self.X = pd.DataFrame(columns = self.space.para_names)
self.y = np.zeros((0, num_model_constr + 1)) # 初始为空数组，随着观测增加
# 设置代理模型名称，决定使用哪种机器学习模型作为目标函数的代理
self.model_name = model_name
# 设置随机采样次数：在开始阶段使用随机探索建立初始模型
# 默认值为空间维度+1，确保至少有2次随机采样
self.rand_sample = 1 + self.space.num_paras if rand_sample is None else max(2, rand_sample)
# 初始化Sobol序列生成器，用于准随机采样（比纯随机采样覆盖更均匀）
# scramble=True启用序列打乱，避免在低维度的相关性
self.scramble_seed = scramble_seed # 保存种子用于 reproducibility
self.sobol = SobolEngine(self.space.num_paras, scramble = True, seed = scramble_seed)
# 设置采集函数类，默认使用MACEConstr（多准则采集函数，带约束处理）
self.acq_cls = acq_cls
# 设置基础模型名称，决定底层使用的建模技术
self.base_model_name = base_model_name
# 存储模型配置，如果为None则使用默认配置
self._model_config = model_config
# 约束相关参数设置
self.num_hard_constr = num_hard_constr # 硬约束：问题固有的物理/逻辑约束
self.num_hidden_constr = num_hidden_constr # 隐藏约束：数据驱动的约束模型
self.max_sequence_length = max_sequence_length # 用于硬约束检查的最大序列长度
# 处理约束阈值y_thres的多种输入格式
if isinstance(y_thres,list):
# 如果输入是列表，转换为numpy数组并重塑为1行多列
self.y_thres = np.array(y_thres).reshape([1, -1])
# 验证列表长度与模型约束数量一致
assert self.y_thres.shape[1] == num_model_constr, 'If give list, please give each output dim one threshold'
elif isinstance(y_thres, int):
# 如果输入是整数，转换为numpy数组并重塑为1行1列
self.y_thres = np.array([y_thres]).reshape([1, -1])
# 验证当输入为整数时，模型约束数量必须为1
assert num_model_constr == 1, 'If give int, only one ouput dim is supported'
elif y_thres is None:
# 如果没有提供约束阈值，设置为None（无约束优化）
self.y_thres = y_thres
def quasi_sample(self, n, fix_input = None):
"""
准随机采样方法：使用Sobol序列在搜索空间内生成均匀分布的初始点
参数：
n: 需要生成的采样点数量
fix_input: 需要固定的输入参数字典，{参数名: 固定值}
返回：
df_samp: DataFrame，包含n个采样点的参数配置
"""
# 从Sobol序列生成n个点在[0,1]^d单位超立方体内
# Sobol序列提供低差异采样，比随机采样覆盖更均匀
samp = self.sobol.draw(n)
# 将[0,1]区间的采样映射到实际参数空间：x_actual = lb + (ub-lb) * x_normalized
# 这里将单位超立方体映射到参数的实际取值范围
samp = samp * (self.space.opt_ub - self.space.opt_lb) + self.space.opt_lb
# 分离连续变量和离散变量：前num_numeric列是连续变量，后面是离散变量
x = samp[:, :self.space.num_numeric] # 连续变量部分
xe = samp[:, self.space.num_numeric:] # 离散变量部分（已编码）
# 对离散化后的连续变量进行取整处理：有些连续参数在变换后需要离散值
for i, n in enumerate(self.space.numeric_names):
if self.space.paras[n].is_discrete_after_transform:
# 如果参数在变换后应该是离散的，对采样值进行四舍五入
x[:, i] = x[:, i].round()
# 将数值转换回原始参数空间：将标准化后的数值转换为实际参数值
# 包括连续变量的缩放和离散变量的解码
df_samp = self.space.inverse_transform(x, xe)
# 如果有需要固定的输入参数，覆盖采样中的对应参数值
if fix_input is not None:
for k, v in fix_input.items():
# 将指定参数的所有采样点设置为固定值
df_samp[k] = v
return df_samp
def suggest(self, n_suggestions=1, fix_input = None, rf_with_thres = None):
"""
生成建议点的主方法：根据历史数据选择下一个评估点
参数：
n_suggestions: 需要生成的建议点数量
fix_input: 需要固定的输入参数字典，在优化过程中保持这些参数不变
rf_with_thres: 随机森林模型及阈值元组，用于评估隐藏约束
返回：
rec_selected: DataFrame，包含选择的n_suggestions个建议点
"""
# 检查并行优化支持：只有MACEConstr采集函数支持并行建议
if self.acq_cls != MACEConstr and n_suggestions != 1:
raise RuntimeError('Parallel optimization is supported only for MACE acquisition')
# 初始随机采样阶段：当历史数据量小于随机采样阈值时
if self.X.shape[0] < self.rand_sample:
# 使用准随机采样生成初始点，建立初始数据集
sample = self.quasi_sample(n_suggestions, fix_input)
# 如果有硬约束，确保采样点满足所有硬约束条件
if self.num_hard_constr:
sample = ensure_hard_constr(sample, max_sequence_length=2**self.max_sequence_length)
return sample # 返回随机采样点
else:
# 贝叶斯优化阶段：当有足够历史数据时，使用模型指导的智能采样
# 转换输入数据：将原始参数转换为模型可处理的数值格式
# X: 连续变量数值，Xe: 离散变量编码
X, Xe = self.space.transform(self.X)
# 处理目标函数数据：使用幂变换增强模型拟合效果
# 幂变换可以使数据更接近正态分布，提高高斯过程模型性能
y_obj = self.y[:,0:1] # 提取目标值（第一列）
y = enable_power_transform(y_obj) # 应用幂变换
# 处理约束数据：如果有模型约束，同样进行变换处理
y_constr = self.y[:, 1:] # 提取约束值（第二列及以后）
y_thres = None # 初始化约束阈值变量
if y_constr.shape[1] > 0:
# 将约束阈值与历史约束数据拼接，一起进行幂变换
# 这样可以确保约束值和阈值在相同的变换空间中
y_constr_with_prefer = np.concatenate([y_constr, self.y_thres], axis = 0)
y_constr_with_prefer = enable_power_transform(y_constr_with_prefer)
# 将变换后的目标值和约束值拼接为完整输出
y = torch.cat([y, y_constr_with_prefer[:-1, ]], axis=1)
# 提取变换后的约束阈值（最后一行）
y_thres = y_constr_with_prefer[-1: ]
# 创建并训练代理模型：使用指定的模型类型和配置
# 模型输入维度：连续变量数 + 离散变量数，输出维度：目标数 + 约束数
model = get_model(self.model_name, self.space.num_numeric, self.space.num_categorical, y.shape[1], **self.model_config)
# 使用历史数据拟合模型，学习目标函数和约束的映射关系
model.fit(X, Xe, y)
# 获取当前最佳点的索引和具体参数配置
best_id = self.get_best_id(fix_input)
best_x = self.X.iloc[[best_id]] # 保持DataFrame结构，使用双括号
# 预测当前最佳点的目标值和不确定性（用于采集函数）
py_best, ps2_best = model.predict(*self.space.transform(best_x))
py_best = py_best[:,0].detach().numpy().squeeze() # 提取目标值预测均值
ps_best = ps2_best[:,0].sqrt().detach().numpy().squeeze() # 提取目标值预测标准差
# 计算自适应kappa参数（探索系数）：随着迭代增加探索性
# kappa控制LCB中的探索程度，值越大越倾向于探索高不确定性区域
iter = max(1, self.X.shape[0] // n_suggestions) # 估算当前迭代次数
upsi = 0.5 # 探索权重参数
delta = 0.01 # 置信水平参数
# 根据理论公式计算kappa，随迭代对数增长
kappa = np.sqrt(upsi * 2 * ((2.0 + self.X.shape[1] / 2.0) * np.log(iter) + np.log(3 * np.pi**2 / (3 * delta))))
# 创建采集函数实例，用于评估候选点的"好坏"
acq = self.acq_cls( model, # 训练好的代理模型
space= self.space, # 搜索空间
num_model_constr = self.y.shape[1]-1, # 模型约束数量
num_hard_constr = self.num_hard_constr, # 硬约束数量
num_hidden_constr = self.num_hidden_constr, # 隐藏约束数量
rf_with_thres = rf_with_thres, # 随机森林约束模型
best_y = py_best, # 当前最佳目标值预测
kappa = kappa, # 探索系数
y_thres = y_thres, # 变换后的约束阈值
max_sequence_length = self.max_sequence_length) # 序列长度限制
# 创建均值和标准差函数，用于后续的候选点选择策略
mu = Mean(model.models[0]) # 均值预测函数
sig = Sigma(model.models[0], linear_a = -1.) # 标准差预测函数，线性系数-1用于后续处理
# 使用进化算法优化采集函数，寻找最有希望的候选点
# pop=100: 种群大小，iters=100: 进化迭代次数
opt = EvolutionOpt(self.space, acq, pop = 100, iters = 100, verbose = False, es=self.es)
# 执行优化，从当前最佳点开始搜索，去除重复点
rec = opt.optimize(initial_suggest = best_x, fix_input = fix_input).drop_duplicates()
# 检查候选点是否与历史观测重复，只保留唯一点
rec = rec[self.check_unique(rec)]
# 如果生成的建议点数量不足，使用随机采样补充
cnt = 0 # 补充尝试计数器
while rec.shape[0] < n_suggestions:
# 生成随机采样点补充不足部分
rand_rec = self.quasi_sample(n_suggestions - rec.shape[0], fix_input)
# 确保随机采样点也满足硬约束
if self.num_hard_constr:
rand_rec = ensure_hard_constr(rand_rec, max_sequence_length=2**self.max_sequence_length)
# 检查随机采样点的唯一性
rand_rec = rand_rec[self.check_unique(rand_rec)]
# 合并到候选点集中
rec = pd.concat([rec, rand_rec], axis = 0, ignore_index = True)
cnt += 1 # 增加尝试计数
if cnt > 3:
# 如果尝试3次后仍不足，可能设计空间很小，重复采样不可避免
break
# 最终检查：如果候选点数量仍不足，强制补充随机采样
if rec.shape[0] < n_suggestions:
rand_rec = self.quasi_sample(n_suggestions - rec.shape[0], fix_input)
if self.num_hard_constr:
rand_rec = ensure_hard_constr(rand_rec, max_sequence_length=2**self.max_sequence_length)
rec = pd.concat([rec, rand_rec], axis = 0, ignore_index = True)
# 从候选点集中选择最终的建议点
# 首先随机选择n_suggestions个点作为基础选择
select_id = np.random.choice(rec.shape[0], n_suggestions, replace = False).tolist()
x_guess = [] # 初始化猜测点列表（未使用）
# 在不计算梯度的情况下评估候选点质量
with torch.no_grad():
# 预测所有候选点的目标值均值和标准差
py_all = mu(*self.space.transform(rec)).squeeze().numpy() # 均值预测
ps_all = -1 * sig(*self.space.transform(rec)).squeeze().numpy() # 标准差预测（取负）
# 找到预测最佳点（均值最小）和不确定性最大点（标准差最大）
best_pred_id = np.argmin(py_all) # 预测目标值最小的点索引
best_unce_id = np.argmax(ps_all) # 不确定性最大的点索引
# 确保选择集中包含重要点：不确定性最大点和预测最佳点
if best_unce_id not in select_id and n_suggestions > 2:
# 如果选择集中没有不确定性最大点且可替换，将其加入
select_id[0]= best_unce_id
if best_pred_id not in select_id and n_suggestions > 2:
# 如果选择集中没有预测最佳点且可替换，将其加入
select_id[1]= best_pred_id
# 从候选点集中提取最终选择的建议点
rec_selected = rec.iloc[select_id].copy() # 使用copy避免视图问题
return rec_selected # 返回最终选择的建议点
GeneralBO
class GeneralBO(AbstractOptimizer):
"""
通用的贝叶斯优化器，支持多目标优化和约束优化
可以处理多个目标函数、模型约束、硬约束和隐藏约束
"""
def __init__(self,
space : DesignSpace, # 设计空间，定义优化参数的取值范围和类型
num_obj: int = 1, # 目标函数的数量，默认为单目标优化
num_model_constr: int = 0, # 模型约束的数量，通过高斯过程建模的约束
num_hard_constr: int = 0, # 硬约束的数量，问题固有的不可违反约束
num_hidden_constr: int = 1, # 隐藏约束的数量，通过随机森林等模型学习的约束
max_sequence_length: int = 12, # 最大序列长度，用于硬约束检查，默认2^12=4096
rand_sample: int = None, # 随机采样阶段的数据量，None时使用默认值
model_name: str = 'multi_task', # 代理模型名称，默认多任务模型
model_config: dict = None, # 模型配置参数字典
kappa: float = 2., # 目标函数的探索系数，控制LCB中的探索程度
c_kappa: float = 0., # 约束函数的探索系数，控制约束边界的探索
use_noise: bool = False, # 是否在预测时添加噪声，增强鲁棒性
evo_pop: int = 100, # 进化算法的种群大小
evo_iters: int = 200, # 进化算法的迭代次数
ref_point: np.ndarray = None, # 多目标优化的参考点，用于计算超体积
scramble_seed: Optional[int] = None # Sobol序列的随机种子，用于可重复的初始采样
):
# 调用父类AbstractOptimizer的构造函数
super().__init__(space)
# 初始化搜索空间和优化问题参数
self.space = space # 设计空间对象
self.num_obj = num_obj # 目标函数数量
self.num_model_constr = num_model_constr # 模型约束数量
self.num_hard_constr = num_hard_constr # 硬约束数量
self.num_hidden_constr = num_hidden_constr # 隐藏约束数量
self.max_sequence_length = max_sequence_length # 最大序列长度限制
# 设置随机采样阶段的数据量：默认值为参数维度+1，确保至少有2次采样
self.rand_sample = 1 + self.space.num_paras if rand_sample is None else rand_sample
# 模型相关参数
self.model_name = model_name # 代理模型类型
self.model_config = model_config if model_config is not None else {} # 模型配置，空字典为默认配置
# 数据存储：X存储历史参数配置，y存储对应的目标值和约束值
self.X = pd.DataFrame(columns = self.space.para_names) # 空的DataFrame，列名为参数名
self.y = np.zeros((0, num_obj + num_model_constr)) # 空的numpy数组，列数为目标+约束
# 采集函数参数
self.kappa = kappa # 目标函数的探索系数
self.c_kappa = c_kappa # 约束函数的探索系数
self.use_noise = use_noise # 是否使用噪声
# 优化过程参数
self.model = None # 代理模型实例，初始为None
self.evo_pop = evo_pop # 进化算法种群大小
self.evo_iters = evo_iters # 进化算法迭代次数
self.iter = 0 # 优化迭代计数器
# 多目标优化参数
self.ref_point = ref_point # 参考点，用于多目标优化的超体积计算
# 初始化Sobol序列生成器，用于准随机初始采样
# scramble=True启用序列打乱，避免低维度相关性
self.sobol = SobolEngine(self.space.num_paras, scramble = True, seed = scramble_seed)
# 验证模型是否支持多输出：如果目标+约束总数>1，模型必须支持多输出
if num_obj + num_model_constr > 1:
assert get_model_class(model_name).support_multi_output
def quasi_sample(self, n, fix_input = None):
"""
准随机采样方法：使用Sobol序列在搜索空间内生成均匀分布的采样点
参数：
n: 需要生成的采样点数量
fix_input: 需要固定的输入参数字典，{参数名: 固定值}
返回：
df_samp: DataFrame，包含n个采样点的参数配置
"""
# 从Sobol序列生成n个点在[0,1]^d单位超立方体内
samp = self.sobol.draw(n)
# 将[0,1]区间的采样映射到实际参数空间：x_actual = lb + (ub-lb) * x_normalized
samp = samp * (self.space.opt_ub - self.space.opt_lb) + self.space.opt_lb
# 分离连续变量和离散变量：前num_numeric列是连续变量，后面是离散变量
x = samp[:, :self.space.num_numeric] # 连续变量部分
xe = samp[:, self.space.num_numeric:] # 离散变量部分（已编码）
# 对离散化后的连续变量进行取整处理
for i, n in enumerate(self.space.numeric_names):
if self.space.paras[n].is_discrete_after_transform:
# 如果参数在变换后应该是离散的，对采样值进行四舍五入
x[:, i] = x[:, i].round()
# 将数值转换回原始参数空间：将标准化后的数值转换为实际参数值
df_samp = self.space.inverse_transform(x, xe)
# 如果有需要固定的输入参数，覆盖采样中的对应参数值
if fix_input is not None:
for k, v in fix_input.items():
df_samp[k] = v
return df_samp
def suggest(self, n_suggestions = 1, fix_input = None, rf_with_thres = None):
"""
生成建议点的主方法：根据历史数据选择下一个评估点
参数：
n_suggestions: 需要生成的建议点数量
fix_input: 需要固定的输入参数字典
rf_with_thres: 随机森林模型及阈值元组，用于评估隐藏约束
返回：
建议点DataFrame，包含n_suggestions个参数配置
"""
# 增加迭代计数器
self.iter += 1
# 初始随机采样阶段：当历史数据量小于随机采样阈值时
if self.X.shape[0] < self.rand_sample:
# 使用准随机采样生成初始点，建立初始数据集
sample = self.quasi_sample(n_suggestions, fix_input)
# 如果有硬约束，确保采样点满足所有硬约束条件
if self.num_hard_constr:
sample = ensure_hard_constr(sample, max_sequence_length=2**self.max_sequence_length)
return sample
else:
# 贝叶斯优化阶段：当有足够历史数据时，使用模型指导的智能采样
# 转换输入数据：将原始参数转换为模型可处理的数值格式
X, Xe = self.space.transform(self.X)
# 将目标值和约束值转换为PyTorch张量
y = torch.FloatTensor(self.y)
# 获取离散变量的类别数量（用于模型初始化）
num_uniqs = None
if Xe.shape[1] > 0: # 如果有离散变量
num_uniqs = [len(self.space.paras[name].categories) for name in self.space.enum_names]
# 创建并训练代理模型
self.model = get_model(self.model_name, X.shape[1], Xe.shape[1], y.shape[1],
num_uniqs=num_uniqs, **self.model_config)
self.model.fit(X, Xe, y) # 使用历史数据训练模型
# 设置探索系数：如果未提供则根据理论公式计算自适应值
kappa = self.kappa
c_kappa = self.c_kappa
upsi = 0.1 # 探索权重参数
delta = 0.01 # 置信水平参数
if kappa is None:
# 自适应kappa计算：随迭代次数对数增长，增加探索性
kappa = np.sqrt(upsi * 2 * ((2.0 + self.X.shape[1] / 2.0) * np.log(self.iter) + np.log(3 * np.pi**2 / (3 * delta))))
if c_kappa is None:
# 自适应c_kappa计算：约束探索系数的类似公式
c_kappa = np.sqrt(upsi * 2 * ((2.0 + self.X.shape[1] / 2.0) * np.log(self.iter) + np.log(3 * np.pi**2 / (3 * delta))))
# 创建通用采集函数，处理多目标和约束优化
acq = GeneralAcq(
self.model, # 训练好的代理模型
self.num_obj, # 目标函数数量
self.num_model_constr, # 模型约束数量
num_hard_constr = self.num_hard_constr, # 硬约束数量
num_hidden_constr = self.num_hidden_constr, # 隐藏约束数量
max_sequence_length = self.max_sequence_length, # 序列长度限制
rf_with_thres = rf_with_thres, # 随机森林约束模型
space = self.space, # 搜索空间
kappa = kappa, # 目标探索系数
c_kappa = c_kappa, # 约束探索系数
use_noise = self.use_noise) # 是否使用噪声
# 使用进化算法优化采集函数，寻找最有希望的候选点
opt = EvolutionOpt(self.space, acq, pop=self.evo_pop, iters=self.evo_iters)
suggest = opt.optimize() # 执行优化，返回候选点
# 如果进化算法找到的候选点数量不足，使用随机采样补充
if suggest.shape[0] < n_suggestions:
# 生成随机采样点补充不足部分
rand_samp = self.quasi_sample(n_suggestions - suggest.shape[0], fix_input)
# 如果有硬约束，确保随机采样点也满足约束
if self.num_hard_constr:
print('GeneralBO before ensure:')
print(rand_samp)
# 应用硬约束确保
rand_samp = ensure_hard_constr(rand_samp, max_sequence_length=2**self.max_sequence_length)
print('GeneralBO after ensure:')
print(rand_samp)
# 合并进化算法结果和随机采样结果
suggest = pd.concat([suggest, rand_samp], axis=0, ignore_index=True)
return suggest
# 如果没有提供参考点（单目标或简单的多目标选择策略）
elif self.ref_point is None:
# 在不计算梯度的情况下评估候选点
with torch.no_grad():
# 预测所有候选点的均值和方差
py, ps2 = self.model.predict(*self.space.transform(suggest))
# 找到不确定性最大的点（各目标对数方差之和最大）
largest_uncert_id = np.argmax(np.log(ps2).sum(axis=1))
# 随机选择n_suggestions个候选点
select_id = np.random.choice(suggest.shape[0], n_suggestions, replace=False).tolist()
# 确保选择集中包含不确定性最大的点（促进探索）
if largest_uncert_id not in select_id:
select_id[0] = largest_uncert_id
return suggest.iloc[select_id] # 返回选择的建议点
else:
# 多目标优化且有参考点的情况：使用EHVI（期望超体积改进）进行选择
assert self.num_obj > 1 # 必须是多目标问题
assert self.num_model_constr == 0 # EHVI目前不支持约束
n_mc = 10 # Monte Carlo采样次数
# 初始化超体积计算器
hv = HV(ref_point=self.ref_point.reshape(-1))
with torch.no_grad():
# 预测候选点的均值和方差
py, ps2 = self.model.predict(*self.space.transform(suggest))
# 从后验分布中采样，获得目标函数的蒙特卡洛样本
y_samp = self.model.sample_y(*self.space.transform(suggest), n_mc).numpy()
# 获取当前的Pareto前沿
y_curr = self.get_pf(self.y).copy()
select_id = [] # 存储选择的点索引
# 依次选择n_suggestions个点
for i in range(n_suggestions):
ehvi_lst = [] # 存储每个候选点的期望超体积改进
base_hv = hv.do(y_curr) # 计算当前Pareto前沿的超体积
# 对每个候选点计算EHVI
for j in range(suggest.shape[0]):
samp = y_samp[:, j] # 候选点j的蒙特卡洛样本
hvi_est = 0 # 超体积改进估计值
# 对每个蒙特卡洛样本计算超体积改进
for k in range(n_mc):
# 将当前样本添加到Pareto前沿中
y_tmp = np.vstack([y_curr, samp[[k]]])
# 计算新的超体积
hvi_est += hv.do(y_tmp) - base_hv # 超体积改进
hvi_est /= n_mc # 取平均得到期望超体积改进
ehvi_lst.append(hvi_est)
# 选择EHVI最大的点，如果没有正改进则随机选择
best_id = np.argmax(ehvi_lst) if max(ehvi_lst) > 0 else np.random.choice(suggest.shape[0])
# 将选择点的最优样本（各目标最小值）添加到当前Pareto前沿
y_curr = np.vstack([y_curr, y_samp[:, best_id].min(axis=0, keepdims=True)])
select_id.append(best_id) # 记录选择的点索引
# 确保选择的点不重复，如果重复则用其他点补充
select_id = list(set(select_id)) # 去重
if len(select_id) < n_suggestions:
# 找出未被选择的候选点
candidate_id = [i for i in range(suggest.shape[0]) if i not in select_id]
# 随机选择补充点
select_id += np.random.choice(candidate_id, n_suggestions - len(select_id), replace=False).tolist()
# 返回最终选择的建议点
return suggest.iloc[select_id]
区别
HEBOConstr:默认使用 MACEConstr（LCB + EI + PI），将三种采集函数组合为多目标优化，使用 Power Transform（Box-Cox 或 Yeo-Johnson）对目标函数进行变换，用 Mean 和 Sigma 选择建议点，优先选择预测值最小和不确定性最大的点
GeneralBO:使用 GeneralAcq（LCB），每个目标都使用 LCB，直接使用原始观测值，不做变换，若提供 ref_point，使用 EHVI（Expected Hypervolume Improvement）选择，否则基于不确定性选择
进化算法选择最优配置
class EvolutionOpt:
"""
进化算法优化器：使用进化算法优化采集函数，寻找最优候选点
支持单目标和多目标优化，处理混合变量（连续和离散）优化问题
"""
def __init__(self,
design_space : DesignSpace, # 设计空间，定义优化参数的取值范围和类型
acq : Acquisition, # 采集函数实例，用于评估候选点的质量
es : str = None, # 进化算法类型，None时自动选择
**conf): # 其他配置参数
# 初始化基本参数
self.space = design_space # 设计空间对象
self.es = es # 进化算法类型
self.acq = acq # 采集函数实例
self.pop = conf.get('pop', 100) # 种群大小，默认100
self.iter = conf.get('iters',500) # 进化迭代次数，默认500
self.verbose = conf.get('verbose', False) # 是否输出详细信息，默认False
self.repair = conf.get('repair', None) # 修复算子，用于处理不可行解
self.sobol_init = conf.get('sobol_init', True) # 是否使用Sobol序列初始化种群，默认True
# 验证采集函数至少有一个目标
assert(self.acq.num_obj > 0)
# 如果没有指定进化算法类型，根据目标数量自动选择
if self.es is None:
# 单目标使用遗传算法(GA)，多目标使用NSGA-II
self.es = 'nsga2' if self.acq.num_obj > 1 else 'ga'
def optimize(self, initial_suggest : pd.DataFrame = None, fix_input : dict = None, return_pop = False) -> pd.DataFrame:
"""
执行进化算法优化过程
参数：
initial_suggest: 初始建议点，用于引导搜索方向
fix_input: 需要固定的输入参数字典
return_pop: 是否返回整个种群而不仅仅是最优解
返回：
df_opt: DataFrame，包含优化得到的候选点参数配置
"""
# 获取设计空间的上下界（转换为numpy数组）
lb = self.space.opt_lb.numpy() # 参数下界
ub = self.space.opt_ub.numpy() # 参数上界
# 创建贝叶斯优化问题实例，将采集函数包装成优化问题
prob = BOProblem(self.acq, self.space, fix_input)
# 初始化种群：使用Sobol序列或随机采样生成初始种群
init_pop = get_init_pop(self.space, self.pop, initial_suggest, self.sobol_init)
# 根据目标数量选择不同的进化算法
if self.acq.num_obj == 1:
# 单目标优化：使用混合变量遗传算法
algo = MixedVariableGA(
pop_size = self.pop, # 种群大小
repair = self.repair, # 修复算子
sampling = init_pop # 初始种群
)
else:
# 多目标优化：使用NSGA-II算法
algo = NSGA2(
pop_size = self.pop, # 种群大小
sampling = init_pop, # 初始种群
mating = MixedVariableMating(eliminate_duplicates = MixedVariableDuplicateElimination()), # 混合变量交配算子
eliminate_duplicates = MixedVariableDuplicateElimination() # 重复个体消除
)
# 执行进化算法优化过程
# ('n_gen', self.iter) 表示运行self.iter代
res = minimize(prob, algo, ('n_gen', self.iter), verbose = self.verbose)
# 处理优化结果
if res.X is not None and not return_pop:
# 如果找到了最优解且不需要返回整个种群
x = res.X # 最优解
# 处理不同格式的解
if isinstance(x, dict):
# 如果解是字典格式，转换为列表
x = [x]
if isinstance(x, np.ndarray):
# 如果解是numpy数组，转换为列表
x = x.tolist()
# 提取参数值并转换为DataFrame
opt_x = pd.DataFrame(x)[self.space.para_names].values.astype(float)
else:
# 返回整个种群或当没有明确最优解时
# 从种群中提取所有个体的参数
opt_x = pd.DataFrame([p.X for p in res.pop])[self.space.para_names].values.astype(float)
# 如果是单目标优化且不需要返回整个种群，随机选择一个个体
if self.acq.num_obj == 1 and not return_pop:
opt_x = opt_x[[np.random.choice(opt_x.shape[0])]]
# 保存优化结果（用于调试和分析）
self.res = res
# 分离连续变量和离散变量
opt_xcont = torch.from_numpy(opt_x[:, :self.space.num_numeric]) # 连续变量部分
opt_xenum = torch.from_numpy(opt_x[:, self.space.num_numeric:]) # 离散变量部分
# 将优化结果转换回原始参数空间
df_opt = self.space.inverse_transform(opt_xcont, opt_xenum)
# 如果有需要固定的输入参数，覆盖优化结果中的对应参数
if fix_input is not None:
for k, v in fix_input.items():
df_opt[k] = v
return df_opt # 返回最终的优化结果
输入：采集函数（定义了一个复杂的优化景观）
输出：在采集函数上得分最高的参数配置
浙公网安备 33010602011771号