自定义搜索算法

在 FlexDMO 平台中，您可以通过自定义搜索算法来利用平台对自己的算法展开研究与实验。本文档将以 NSGA2 算法为例，详细介绍如何实现一个符合平台规范的搜索算法。通过遵循以下4步，您的算法将被平台正确识别并支持调试功能。

1. 创建相关文件

在 algorithms/search_algorithm/NSGA2 目录下需要创建以下文件：

NSGA2/
  ├── main.py         # 算法主实现文件，包含核心优化逻辑
  ├── config.json     # 算法配置文件，定义算法参数
  ├── info.json       # 算法信息文件，包含算法的相关信息

2. 编写配置文件(config.json)

配置文件用于定义算法的超参数，这些参数将被平台读取并显示在参数设置界面中，供用户调整：

json

{
  "proC": 1.0,
  "disC": 10,
  "proM": 1.0,
  "disM": 10
}

如下图所示，配置文件中的参数将被平台自动解析并生成参数设置界面，用户可以通过界面调整这些参数值。参数值的修改将直接影响算法的性能和行为。

3. 编写算法信息(info.json)

算法信息文件用于定义算法的基本信息，这些信息将被平台读取并显示在算法选择界面中：

json

{
  "year": 2002,
  "name": "NSGAII"
}

如下图所示，算法信息将被平台自动解析并显示在算法选择界面中，帮助用户了解算法的基本信息。算法信息显示

4. 编写算法实现(main.py)

在 FlexDMO 平台中，所有算法都需要继承自 Algorithm 抽象类。这个抽象类定义了算法必须实现的方法和属性，确保算法能够与平台正确交互。主要需要实现的方法包括：

__init__ 方法：
- 用于初始化算法参数
- 从 config.json 读取配置参数
- 调用父类初始化方法
optimize 方法：
- 算法的核心优化过程
- 处理环境变化检测
- 实现进化操作
- 收集优化信息

接下来，将分别介绍如何实现这两个方法：

`init` 方法

__init__ 方法是算法的构造函数，主要负责初始化算法的参数和状态。首先给出NSGAII的源码例子：

python

class NSGA2(Algorithm):
    """
    NSGA2 算法实现类
    实现了基于非支配排序的多目标优化算法
    支持动态环境变化检测和响应
    """
    def __init__(self, proC=1.0, disC=10, proM=1.0, disM=10, **args):
        """
        初始化 NSGA2 算法
        
        参数:
            proC (float): 交叉概率，默认 1.0，从config.json读取
            disC (float): 交叉分布指数，默认 10，从config.json读取
            proM (float): 变异概率，默认 1.0，从config.json读取
            disM (float): 变异分布指数，默认 10，从config.json读取
        """
        super().__init__(**args)
        self.proC = proC  # 交叉概率
        self.disC = disC  # 交叉分布指数
        self.proM = proM  # 变异概率
        self.disM = disM  # 变异分布指数

关于参数初始化的说明

注意：虽然平台会自动从 config.json 读取参数值，但建议为参数设置默认值，以提高代码的可移植性和可测试性。

1. 默认值设置

虽然平台会自动从 config.json 读取参数值
但建议为参数设置默认值，便于：
- 直接运行代码测试
- 独立于平台使用
- 提高代码可移植性

2. 参数来源优先级

平台配置（最高优先级）
构造函数参数
默认值（最低优先级）

`optimize` 方法

optimize 方法是算法的核心，负责执行整个优化过程。这个方法定义了算法如何迭代地改进解，直到达到终止条件。下面是一个完整的实现示例：

python

def optimize(self, problem, response_strategy):
    # 初始化种群
    pop = Population(xl=problem.xl, xu=problem.xu, n_init=problem.solution_num)
    pop.update_objective_constrain(problem)
    
    while not problem.is_ended() and self.control_process():
        # 检测环境变化
        if detection(pop, problem, int(0.1 * problem.solution_num)) == 1:
            pop = response_strategy.response(pop, problem, self)
            self.collect_information(pop, problem, response_strategy)  # 收集运行信息
            continue
            
        # 生成子代
        offspring = self._variation(pop, problem)
        offspring.update_objective_constrain(problem)
        
        # 合并父代和子代
        combined = Population(individuals=pop.individuals + offspring.individuals, 
                            xl=problem.xl, xu=problem.xu)
        
        # 环境选择
        pop = self._environmental_selection(combined, problem)
        
        self.collect_information(pop, problem, response_strategy)  # 收集运行信息

方法参数说明

problem: 优化问题实例，包含问题的约束和目标函数
response_strategy: 环境变化响应策略实例，用于处理动态环境变化

实现步骤详解

1. 种群初始化

python

pop = Population(xl=problem.xl, xu=problem.xu, n_init=problem.solution_num)
pop.update_objective_constrain(problem)

创建初始种群，设置决策变量的上下界
使用问题实例更新种群的约束条件

2. 主循环控制

python

while not problem.is_ended() and self.control_process():

problem.is_ended(): 检查是否达到终止条件
self.control_process(): 平台提供的进程控制机制

3. 环境变化检测与响应

python

if detection(pop, problem, int(0.1 * problem.solution_num)) == 1:
    pop = response_strategy.response(pop, problem, self)
    self.collect_information(pop, problem, response_strategy)
    continue

使用 detection 方法检测环境变化
如果检测到变化，使用响应策略处理
收集并保存当前状态信息

4. 进化操作

python

# 生成子代
offspring = self._variation(pop, problem)
offspring.update_objective_constrain(problem)

# 合并父代和子代
combined = Population(individuals=pop.individuals + offspring.individuals, 
                     xl=problem.xl, xu=problem.xu)

# 环境选择
pop = self._environmental_selection(combined, problem)

通过变异操作生成子代
更新子代的约束条件
合并父代和子代
使用环境选择更新种群

5. 信息收集

python

self.collect_information(pop, problem, response_strategy)

收集并保存优化过程中的关键信息
包括种群状态、适应度值等
这些信息可以通过 self.history 访问，详细结构请参考算法文档中的相关章节

使用示例

下面提供一个完整的算法模板，您可以直接复制并修改来实现自己的算法。这个模板包含了所有必要的组件和注释，您只需要关注核心优化逻辑的实现。

1. 创建算法目录

首先，在 algorithms/search_algorithm/ 目录下创建您的算法目录，例如 MyAlgorithm：

algorithms/search_algorithm/MyAlgorithm/
  ├── main.py         # 算法主实现文件
  ├── config.json     # 算法配置文件
  ├── info.json       # 算法信息文件

2. 配置文件模板

config.json

json

{
  "param1": 1.0,    // 参数1的默认值
  "param2": 10,     // 参数2的默认值
  "param3": 0.5     // 参数3的默认值
}

info.json

json

{
  "year": 2024,     // 算法发表年份
  "name": "MyAlgorithm"  // 算法名称
}

3. 算法实现模板

复制以下代码到 main.py，然后根据您的算法需求修改相关部分：

python

from algorithms.search_algorithm.Algorithm import Algorithm
from components.Population import Population
from utils.evolution_tools import detection

class MyAlgorithm(Algorithm):
    """
    您的算法实现类
    继承自Algorithm基类，实现必要的接口方法
    """
    def __init__(self, param1=1.0, param2=10, param3=0.5, **args):
        """
        初始化算法参数
        
        参数:
            param1 (float): 参数1的说明
            param2 (float): 参数2的说明
            param3 (float): 参数3的说明
        """
        super().__init__(**args)
        # 初始化您的算法参数
        self.param1 = param1
        self.param2 = param2
        self.param3 = param3
        
        # TODO: 在这里添加其他初始化代码
        # 例如：初始化其他变量、数据结构等

    def optimize(self, problem, response_strategy):
        """
        优化过程的主函数
        
        参数:
            problem: 优化问题实例
            response_strategy: 环境变化响应策略实例
        """
        # 1. 初始化种群
        pop = Population(xl=problem.xl, xu=problem.xu, n_init=problem.solution_num)
        pop.update_objective_constrain(problem)
        
        # 2. 主循环
        while not problem.is_ended() and self.control_process():
            # 2.1 检测环境变化
            if detection(pop, problem, int(0.1 * problem.solution_num)) == 1:
                pop = response_strategy.response(pop, problem, self)
                self.collect_information(pop, problem, response_strategy)
                continue
            
            # 2.2 实现您的优化逻辑
            # TODO: 在这里实现您的算法核心逻辑
            # 例如：
            # - 选择操作
            # - 交叉操作
            # - 变异操作
            # - 其他进化操作
            
            # 2.3 更新种群
            pop = self._update_population(pop, offspring)
            
            # 2.4 收集信息
            self.collect_information(pop, problem, response_strategy)
        
        return pop

    # TODO: 在这里添加您的辅助方法
    # 例如：
    # def _selection(self, pop):
    #     """选择操作"""
    #     pass
    #
    # def _crossover(self, parents):
    #     """交叉操作"""
    #     pass
    #
    # def _mutation(self, offspring):
    #     """变异操作"""
    #     pass

使用说明

复制上述模板到您的算法目录中
修改 config.json 和 info.json 中的参数和信息
在 main.py 中：
- 修改类名和文档字符串
- 在 __init__ 中添加您的算法参数
- 在 optimize 方法中实现您的优化逻辑
- 添加必要的辅助方法

4. 测试您的算法

python

from problems.benchmark.DP1.main import DP1
from algorithms.response_strategy.NoResponse.main import NoResponse

# 创建算法实例
myalg = MyAlgorithm()

# 创建响应策略实例
response = NoResponse()

# 创建问题实例
problem = DP1(10, 10, 20, 100, 30)  # 参数说明：决策变量维度=10，目标函数维度=10，种群大小=20，最大迭代次数=100，环境变化周期=30

# 执行优化过程
result = myalg.optimize(problem, response)

WARNING

在实现自定义算法时，请特别注意以下几点：

确保您的算法类继承自 Algorithm 基类
实现必要的 __init__ 和 optimize 方法
在优化过程中定期调用 self.collect_information 收集信息
使用 self.control_process() 检查是否需要终止优化
正确处理环境变化检测和响应

通过这个模板，您可以快速开始实现自己的算法，并确保它能够与平台正确集成。如果您有任何问题，请参考平台的其他文档或提交issue。

自定义搜索算法 ​

1. 创建相关文件 ​

2. 编写配置文件(config.json) ​

3. 编写算法信息(info.json) ​

4. 编写算法实现(main.py) ​

__init__ 方法 ​

关于参数初始化的说明 ​

1. 默认值设置 ​

2. 参数来源优先级 ​

optimize 方法 ​

方法参数说明 ​

实现步骤详解 ​

1. 种群初始化 ​

2. 主循环控制 ​

3. 环境变化检测与响应 ​

4. 进化操作 ​

5. 信息收集 ​

使用示例 ​

1. 创建算法目录 ​

2. 配置文件模板 ​

config.json ​

info.json ​

3. 算法实现模板 ​

4. 测试您的算法 ​

自定义搜索算法

1. 创建相关文件

2. 编写配置文件(config.json)

3. 编写算法信息(info.json)

4. 编写算法实现(main.py)

`init` 方法

关于参数初始化的说明

1. 默认值设置

2. 参数来源优先级

`optimize` 方法

方法参数说明

实现步骤详解

1. 种群初始化

2. 主循环控制

3. 环境变化检测与响应

4. 进化操作

5. 信息收集

使用示例

1. 创建算法目录

2. 配置文件模板

config.json

info.json

3. 算法实现模板

4. 测试您的算法