如何在TensorFlow/Keras中实现自定义生物优化器并作为内置优化器？

问题核心 #

你遇到的ValueError: Could not interpret optimizer identifier错误，本质是IMRFO并非TensorFlow/Keras原生优化器体系的子类。Keras的model.compile()要求传入的优化器必须继承自keras.optimizers.Optimizer基类，而当前的IMRFO是独立的种群优化实现，和Keras的参数更新逻辑不兼容。

适配方案 #

要让IMRFO能用于训练Keras模型，需要将其重构为符合Keras规范的优化器，核心思路是把神经网络的参数作为IMRFO种群优化的目标变量，将种群迭代逻辑嵌入Keras的参数更新流程中。

步骤1：继承Keras Optimizer基类 #

让IMRFO类继承keras.optimizers.Optimizer，并实现Keras优化器要求的核心方法，同时处理TensorFlow的变量追踪。

步骤2：重构IMRFO核心逻辑 #

将原IMRFO的种群初始化、迭代更新逻辑，适配为针对Keras模型参数的操作。由于IMRFO是种群优化算法，需要维护参数的种群集合，每次迭代计算每个种群个体的损失，选择最优个体更新模型参数。

以下是适配后的代码示例：

import tensorflow as tf
from tensorflow.keras.optimizers import Optimizer
import numpy as np

class KerasIMRFO(Optimizer):
    def __init__(self, epoch=10000, pop_size=100, somersault_range=2.0, name="KerasIMRFO", **kwargs):
        super().__init__(name, **kwargs)
        self.epoch = epoch
        self.pop_size = pop_size
        self.somersault_range = somersault_range
        # 种群相关变量，将在build时初始化
        self.population = None
        self.g_best = None
        self.current_epoch = tf.Variable(0, dtype=tf.int32)

    def build(self, var_list):
        super().build(var_list)
        # 初始化种群：每个个体是模型参数的副本，添加随机扰动
        self.population = []
        for _ in range(self.pop_size):
            individual = []
            for var in var_list:
                # 基于参数初始值生成种群个体
                perturbed = var + tf.random.normal(var.shape, mean=0, stddev=0.01)
                individual.append(tf.Variable(perturbed))
            self.population.append(individual)
        # 初始化全局最优
        self.g_best = self.population[0].copy()

    def minimize(self, loss, var_list, tape=None):
        # 重写minimize方法，实现种群优化的完整流程
        for epoch in range(self.epoch):
            self.current_epoch.assign(epoch)
            # 计算每个种群个体的损失
            fitness = []
            for individual in self.population:
                # 将个体参数赋值给模型
                for var, ind_var in zip(var_list, individual):
                    var.assign(ind_var)
                # 计算损失
                with tf.GradientTape() as tape:
                    current_loss = loss()
                fitness.append(current_loss.numpy())
            # 找到当前最优个体
            best_idx = np.argmin(fitness)
            self.g_best = self.population[best_idx].copy()
            # 执行IMRFO的种群更新逻辑
            self.evolve()
            # 打印进度
            if epoch % 100 == 0:
                print(f"Epoch {epoch}, Best Loss: {fitness[best_idx]}")
        # 训练结束后，将最优参数赋值给模型
        for var, best_var in zip(var_list, self.g_best):
            var.assign(best_var)

    def evolve(self):
        # 原IMRFO的evolve逻辑，适配为TensorFlow变量操作
        pop_new = []
        for idx in range(self.pop_size):
            if tf.random.uniform(()) < 0.5:
                # Cyclone foraging
                r1 = tf.random.uniform(())
                beta = 2 * tf.exp(r1 * (self.epoch - self.current_epoch) / self.epoch) * tf.sin(2 * np.pi * r1)
                if (self.current_epoch + 1) / self.epoch < tf.random.uniform(()):
                    # 生成随机个体
                    x_rand = []
                    for var in self.g_best:
                        lb = tf.reduce_min(var)
                        ub = tf.reduce_max(var)
                        x_rand.append(tf.random.uniform(var.shape, lb, ub))
                    if idx == 0:
                        x_t1 = [xr + tf.random.uniform(())*(xr - self.population[idx][i]) + beta*(xr - self.population[idx][i]) 
                                for i, xr in enumerate(x_rand)]
                    else:
                        x_t1 = [xr + tf.random.uniform(())*(self.population[idx-1][i] - self.population[idx][i]) + beta*(xr - self.population[idx][i]) 
                                for i, xr in enumerate(x_rand)]
                else:
                    if idx == 0:
                        x_t1 = [gb + tf.random.uniform(())*(gb - self.population[idx][i]) + beta*(gb - self.population[idx][i]) 
                                for i, gb in enumerate(self.g_best)]
                    else:
                        x_t1 = [gb + tf.random.uniform(())*(self.population[idx-1][i] - self.population[idx][i]) + beta*(gb - self.population[idx][i]) 
                                for i, gb in enumerate(self.g_best)]
            else:
                # Chain foraging
                r = tf.random.uniform(())
                alpha = 2 * r * tf.sqrt(tf.abs(tf.math.log(r)))
                if idx == 0:
                    x_t1 = [self.population[idx][i] + r*(gb - self.population[idx][i]) + alpha*(gb - self.population[idx][i]) 
                            for i, gb in enumerate(self.g_best)]
                else:
                    x_t1 = [self.population[idx][i] + r*(self.population[idx-1][i] - self.population[idx][i]) + alpha*(gb - self.population[idx][i]) 
                            for i, gb in enumerate(self.g_best)]
            # 修正参数范围
            pos_new = [tf.clip_by_value(x, tf.reduce_min(var), tf.reduce_max(var)) for x, var in zip(x_t1, self.g_best)]
            pop_new.append(pos_new)
        # 更新种群
        self.population = pop_new
        # Somersault foraging
        pop_child = []
        for idx in range(self.pop_size):
            x_t1 = [self.population[idx][i] + self.somersault_range*(tf.random.uniform(())*gb - tf.random.uniform(())*self.population[idx][i]) 
                    for i, gb in enumerate(self.g_best)]
            pos_new = [tf.clip_by_value(x, tf.reduce_min(var), tf.reduce_max(var)) for x, var in zip(x_t1, self.g_best)]
            pop_child.append(pos_new)
        # 贪婪选择更新种群
        self.population = pop_child

步骤3：使用适配后的优化器训练模型 #

修改SNN训练代码，使用KerasIMRFO替代原IMRFO，直接调用优化器的minimize方法完成训练：

def snn(X_train,Y_train,X_test,Y_test):
    model = tf.keras.Sequential()
    model.add(tf.keras.layers.Dense(100, input_dim=X_train.shape[1], activation='relu'))
    model.add(tf.keras.layers.Dense(3, activation='softmax'))

    # 初始化适配后的优化器
    custom_optimizer = KerasIMRFO(epoch=10000, pop_size=100, somersault_range=2.0)

    # 定义损失函数
    def loss_fn():
        y_pred = model(X_train, training=True)
        return tf.keras.losses.sparse_categorical_crossentropy(Y_train, y_pred)

    # 使用优化器最小化损失
    custom_optimizer.minimize(loss_fn, model.trainable_variables)

    # 评估模型
    y_pred = np.argmax(model.predict(X_test), axis=1)
    return y_pred, tf.math.confusion_matrix(Y_test, y_pred)

关键说明 #

• 种群优化算法（如IMRFO）和传统梯度优化逻辑差异很大，无法直接套用Keras的单参数更新模式，因此需要重写minimize方法实现完整的种群迭代流程。
• 代码中需要将原IMRFO的numpy操作替换为TensorFlow的张量操作，确保兼容自动微分和GPU加速。
• 可以根据需求调整种群初始化的扰动范围、参数边界的处理逻辑，以适配你的SNN模型。

内容的提问来源于stack exchange，提问作者Alosh Denny