SMAC

1. Facade
2. 文档最完善的入口类： smac.facade.smac_ac_facade.SMAC4AC

1. Facade.optimize() –> SMBO.run() (Facade.solver().run())

2. SMBO.run() 迭代循环

   1. Intensifier.get_next_run() (SMBO.run()–> SMBO.intensifier.get_next_run()) –> AbstractRacer._next_challenger()

      • AbstractRacer 是 Intensifier 的基类
      • 选择下一个 challenger (候选配置config)

      • 方法：

        • 使用 EPM(代理模型) EPMChooser 选择

      • 参数：

        • SMBO.epm_chooser
        • runhistory
        • num_workers
        • challengers: 如果手动提供 challengers 使用他们，否则使用 epm_chooser 生成

   2. AbstractRacer._next_challenger() –> EPMChooser.choose_next() (SMBO.epm_chooser.choose_next())

      • 内部：

        • 使用 acquisition_function 采集函数，排序参数 config

        • EPMChooser.choose_next() —> :

          1. 初次迭代： 随机搜索 –> EPMChooser._random_search.maximize() (AcquisitionFunctionMaximizer.maximize())
          2. 后续迭代： –> 自定义的 Acquisition_function_Maximizer.maximize() (AcquisitionFunctionMaximizer.maximize())

      • EPMChooser.choose_next() 内部

        1. 获取历史数据：通过 EPMChooser.runhistory 获取 (X, Y, X_configs) 迭代历史数据， EPMChooser._collect_data_to_train_model()

           • 使用 EPMChooser.rh2EPM.transform(runhistory) 把RunHistory 变成 (X, Y) 代理模型友好的数据格式

             • EPMChooser.rh2EPM: AbstractRunHistory2EPM 抽象基类

               • 内部处理 多目标 multit-object 数据的Cost 转换 cost 数组 –> 单个 float cost 数值

           • epm_chooser.choose_next() 中的参数

             • X_configurations: 所有的 configuration 以 np.array 形式存储的数据，包括失败的和成功的参数， 和 X 类似
             • X, Y: 通过最大 budget 筛选出来的成功 和 timeout 的 Config
             • best_observation: 是 cost
             • x_best_array: incumbent_value 对应的 X 取值
             • _get_x_best() –> self.model.predict_marginalized_over_instances(X) -> mean, var
        2. 训练代理模型： EPMChooser.model.train(X, Y)

        3. 更新 incumbent (最好参数), 存储在 EPMChooser.acquisition_function 实例内部

           1. 如果传入和 incumbent_value, 使用这个 incumbent_value

           2. 否则，通过 (EPMChooser) self._get_x_best(predict, X), 计算出最佳值， incumbent_value

              • self._get_x_best(predict, X) 使用X + 代理模型，计算出Y_predict
              • Y_predict –> mean, var 均值和方差
              • 使用 Y_predict 的 mean 作为 costs –> 计算 x_best, incumbent_value

           3. _get_x_best() –> self.model.predict_marginalized_over_instances(X) -> mean, var

              • 对于不需要 instance_features 情况：

                • 直接返回 proxymodel.predict(X) –> mean, var

                  1 2 3 4 5 6 7 8

                  if self.instance_features is None or \ len(self.instance_features) == 0: mean_, var = self.predict(X) assert var is not None # please mypy var[var < self.var_threshold] = self.var_threshold var[np.isnan(var)] = self.var_threshold return mean_, var

                • 使用 mean_ –> 作为 cost 对 X 排序获得 x_best 和 best_observation(incumbent_value)
        4. 采集函数 最好值更新 self.acquisition_function()

        5. 获取新生成X, 作为下一轮的 chanllengers

           • self.acq_optimizer.maximize(runhistory, stats, num_points, random_config_chooser)

             • 基于（1）采集函数（2）历史数据（3）最佳样本点（4）随机选择器（5）maximizer 生成新的 configs(参数 Xs)
        6. 去重： 去掉以前已经运行过的参数 config
        7. maximizer.maximize() –> Iterator[Configuration]
   3. 通过生成 (RunInfoIntent, config) 返回值判断是否需要运行

   4. RunInfoIntent.RUN: Runner.submit_run() 负责运行，存储结果到 Runner.results 字段中

      1. SMBO.run() –> Runner.submit_run() (SMBO.tae_runner.submit_run(run_info))

      2. Runner.submit_run() –> Runner.run_wrapper(run_info)

         1	def run_wrapper( self, run_info: RunInfo, ) -> Tuple[RunInfo, RunValue]:

         • 内部负责调用 Runner.run()

         • 负责确定运行结果状态 status

           • StatusType.STOP: 退出整个 SMBO 循环(实际源码中没有发现主动赋值 StatusType.STOP 的情况)

      3. Runner.submit_run() –> Runner.run()

         • Runner: 所有 runnner 的基类
         • smac.tae.execute_func.AbstractTAFunc: 用来执行算法的 Runner 抽象类

         1 2	def run(self, config: Configuration, instance: str, cutoff: Optional[float] = None, seed: int = 12345, budget: Optional[float] = None, instance_specific: str = "0") -> Tuple[StatusType, float, float, Dict]: # Tuple[status: int, cost: np.ndarrray, runtime: float, additional_info: dict]

      4. 运行结果存储：

         • Runner.results: Dict[RunInfo, RunValue]

   5. 结果处理： –> SMBO._incorporate_run_results

      • 把结果存储到 SMBO.runhistory (smac.runhistory.Runhistory) 中

      • intensifier: 处理 racer 和 incumbent 竞争问题

        • 替换和裁定最新的 incumbent (最好结果)

        • SMBO.intensifier.process_results(run_info: RnInfo, incumbent, run_history, result: RunValue)

          • 功能： 添加当前点（RunInfo, RunValue）

          • AbstractRacer. _compare_configs (previous_incumbent, challenger, runhistory)

            • 功能： 更新最好点 ，比较以前的最好点 previous_incumbent，和新添加的点 challenger

            • cost 获得方法 ：

              • 通过 RunHistory.average_cost(config, …) 方法获得
              • 先正规化，再求平均值
              • 多目标 multi-objectives 处理： 通过直接平均，把多个 ojectives 转换成单个 cost
            • chall_cost < previous_incumbent_cost —> 挑战成功
      • callback 回调函数调用

   6. 结束SMBO循环

      • 资源耗尽 budget 或者 result.status == StatusType.STOP,

内部涉及到了两种场景：

1. 添加样本点时： SMBO._incorporate_run_results() –> SMBO.intensifier.process_results(RunInfo, RunValue, …) –> SMBO.intensifier._compare_configs(previous_incumbent, challenger)

   • 内部真正执行比较的是： SMBO.intensifier._compare_configs(previous_incumbent, challenger)

     • 通过正规化 + 简单平均把 multi-objectives 转换成单个cost, 评估最好点
   • 存储到 SMBO.incumbent 中

2. 生成下一个样本点时：在 SMBO.run() –> SMBO.get_next_run() –> SMBO.intensifier.EPMChooser.choose_next() 为了获得下一个 challengers 时

   • 在更新代理模型之前，把 runhistory 转换成 X, Y, 通过 multi_objective_algorithm 把 multi-objectives 转换成单个 cost

     • 调用位置： 在 SMBO.epmchooser._collect_data_to_train_model() 内部
     • x 是 configs array –> list[x] –> X
     • y 是 转换后的 单个 cost 列表 –> list[y] –> Y

   • 更新代理模型

     • 代理模型的单目标 Vs 多目标

       • 默认情况下，内部代理函数实现是 X –> y 模型，预测单个 cost (单目标)

       • 如果需要实现多目标预测，需要手动改写 代理模型的实现，重载 AbstractEPM.train(), AbstractRacer._train(), AbstractEPM.predict(), AbstractEPM._predict()

         • 在保持内部 外部接口的 X –> y 基础上，内部能够实现 X –> Y –> y 的两种预测模式

   • 获取最好点

     • 可以通过传参传入 到 choose_next() 中

     • 如果没有，通过 EPMChooser._get_x_best(X) 通过代理模型 + X(历史 configs) 筛选出来

       • 代理模型的单目标 Vs 多目标

         • 这里默认使用 X –> y 单个cost 的代理模型
         • 如果是预测多目标的代理模型，需要手动实现代理函数内部的多目标 —> 单目标（X –> Y –> y）
   • 使用 (代理模型， best_point, random_chooser) + EPMChooser.acq_optimizer 生成下一个 challengers

1. 基础类型： AbstractEPM

2. 存储位置

   • facade.solver (SBMO) –> emp_chooser (EPMChooser) –> model (AbstractEPM)

   • 相关类

     1. Facade: eg: SMAC4HPO, SMAC4AC

        • 入口类

     2. SMBO:

        • 管理贝叶斯循环

     3. EPMChooser

        • 训练概率代理模型 EPM, 生成下一个超参数 config (epm_chooser.choose_next())

        • choose_next() 中（1）先会完成训练，再（2）生成下一个 config

          • 利用runhistory 获取历史数据

3. epm mode 创建流程：

   1. 在 Facade 类中创建

   2. 在 SMBO 中作为 EPMChooser 的参数用来创建 EPMChooser

      • 创建后只有和 EPMChooser 发生了实际的关系

4. 替换model(代理模型) 方法：

   • 直接修改 facade.solver.emp_chooser.model 即可

5. 替换 epm_chooser 方法：

   • 直接替换 facade.solver.epm_chooser 即可
   • 注意里面引用的 scenario, stats, runhistory, model 等对象的引用，不要使用新建的，要是在 facade, smbo 中引用的

1. ConfigSpace: automl 系列工具

   • Quickstart - ConfigSpace

   • 用途：

     • 限制取值范围： ConfigurationSpace
     • 参数之间的相互依赖关系： EqualsCondition

     • 记录多次迭代参数变更历史

       • 类似实例化包含一个 ConfigurationSpace
     • 调用不同的模型

1. 参数： config

   • 在 smac 中，parameter 参数或者 HyperParamter 超参数被称作 configuration | config

2. challenger

   • smac 选出的候选参数
   • 相关工具： ChallengerList

3. trial

   • 一次黑盒函数的运行
   • 包括整合相关要素：config, seed, budget, instance

4. incumbent, current incumbent

   • 当前效果最好的参数 best_config
   • 注意： 如果是 multi-objective 多目标优化，可能有多组最好参数 multiple current incumbent
   • incumbent 存储在 Intensifier 中
   • incumbent 值存储在 AquisitionFunction.eta 中 (best_observation), 参数在 AquisitionFunction.incumbent_array=x_best_array

5. optimizer: SMBO

   • 贝叶斯优化循环工具类实例： SMBO 对象
   • Facade.optimizer() –> SMBO

6. instance: 数据集

   • smac 允许被优化模型使用多个数据集，一个数据集或数据子集，被称为一个 instance
   • 需要在 Scenario 类中声明 instance 列表

7. hyperband:

   • 一种超参数调优，资源分配策略，可以用来筛选出性能较好的参数
   • Hyperband的核心思想是结合了随机搜索和贝叶斯优化的优点，通过动态地分配资源来快速识别出性能较好的超参数配置

8. imputator

   • 数据缺失填充器： RFRImputator

9. epm_chooser

   • 负责 epm(代理模型)、采集函数、acquisition function maximizer 、run_history 、 scenario 之间的互相调用

   • 作用：

     1. 使用 run_history 中的数据，训练代理模型
     2. 使用代理模型 + 采集函数 + maximizer –> 生成新的参数 config

10. run_obj:

    • 实际使用到的地方

      • Scenario: 只是存储这个参数
      • Runner:

11. censored: 截断数据

    • Censored 数据是指在超参数优化过程中，由于某些超参数组合的评估成本过高或耗时过长，导致其评估结果被提前终止或截断。这些被截断的评估结果通常只包含部分信息，如部分迭代次数的训练结果。

参考：

• Components — SMAC3 Documentation 2.2.0 documentation

1
2
3
4
5
6
7

self.acquisition_func.update(
    model=self.model,
    eta=best_observation,
    incumbent_array=x_best_array,
    num_data=len(self._get_evaluated_configs()),
    X=X_configurations,
)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

SMAC4AC(

# 传入创建参数
initial_design_kwargs={
            "ta_run_limit": scenario.ta_run_limit,  # type: ignore[attr-defined] # noqa F821
            "configs": initial_configurations,
            "n_configs_x_params": 0, # 初始化使用的参数组数
            "max_config_fracs": 0.0,
        }
)

# 手动创建 InitialDesign 类的实例
inital = InitialDesign()
SMAC4AC(
initial_configurations=initial,
...
)

保存文件夹中的 runhistory.json

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

{
    "data": [
        [
            [1,                 # 迭代序号
             null, 0, 0.0],
            [
                -2.2500963017546054,  # cost 损失函数
                5.14984130859375e-05,
                {"__enum__": "StatusType.SUCCESS"},
                1736150375.9613395, # 开始时间戳
                1736150375.9613993, # 结束时间戳
                {},
            ],
        ],
        [
            [2, null, 0, 0.0],
            [
                -2.3674935445507694,
                3.504753112792969e-05,
                {"__enum__": "StatusType.SUCCESS"},
                1736150375.9627178,
                1736150375.96276,
                {},
            ],
        ],
    ],
    "config_origins": {  # 每一次迭代参数的生成方式，
        "1": "Sobol",
        "2": "Sobol",
        "4": "Random Search (sorted)",
        "5": "Random Search",
    },
    "configs": {  # 每一次迭代生成的超参数，对应的 cost 见上文
        "1": {
            "x0": 0.764471385627985,
            "x1": 0.03850575536489487,
            "x2": 0.400804003700614,
            "x3": 0.22312777861952782,
        },
        "2": {
            "x0": 0.32599365059286356,
            "x1": 0.7236258173361421,
            "x2": 0.8391415951773524,
            "x3": 0.879259736277163,
        },
    },
}

• runhistory.json : config 和 cost 记录
• stats : 运行的总体状况数据汇总，用时、迭代次数
• configspace: 参数取值范围
• traj.json: 每一次黑盒函数运行的具体运行数据

deepseek 对话 prompt:

• smac epm中的featture 是什么，感觉不是 超参数（config)
• 举一个同时包含config和figure的epm 训练数据的例子