采用蚁群算法对BP神经网络进行优化

# 假设神经网络结构：输入层2节点，隐藏层3节点，输出层1节点
# 总参数数 = (2×3) + (3×1) + 3 + 1 = 6 + 3 + 3 + 1 = 13个参数
​
# 一只蚂蚁代表一组完整的网络参数
ant = [w11, w12, w13, w21, w22, w23,  # 输入层到隐藏层权重
       w31, w32, w33,                  # 隐藏层到输出层权重
       b1, b2, b3,                     # 隐藏层偏置
       b4]                             # 输出层偏置

import numpy as np
​
class ACO_BP_Network:
    def __init__(self, network_structure):
        self.network_structure = network_structure  # 如 [2, 3, 1]
        self.param_count = self.calculate_parameters()
        
    def calculate_parameters(self):
        """计算神经网络总参数数量"""
        total = 0
        for i in range(len(self.network_structure)-1):
            total += self.network_structure[i] * self.network_structure[i+1]  # 权重
            total += self.network_structure[i+1]  # 偏置
        return total
    
    def ant_to_network(self, ant_position):
        """将蚂蚁位置解码为神经网络权重矩阵和偏置向量"""
        weights = []
        biases = []
        start_idx = 0
        
        for i in range(len(self.network_structure)-1):
            input_size = self.network_structure[i]
            output_size = self.network_structure[i+1]
            
            # 提取权重矩阵
            weight_count = input_size * output_size
            weight_flat = ant_position[start_idx:start_idx+weight_count]
            weight_matrix = weight_flat.reshape((output_size, input_size))
            weights.append(weight_matrix)
            start_idx += weight_count
            
            # 提取偏置向量
            bias_count = output_size
            bias_vector = ant_position[start_idx:start_idx+bias_count]
            biases.append(bias_vector)
            start_idx += bias_count
            
        return weights, biases
    
    def fitness_function(self, ant_position, X_train, y_train):
        """适应度函数：使用当前权重计算网络误差"""
        weights, biases = self.ant_to_network(ant_position)
        
        # 前向传播计算误差
        mse = self.forward_pass(weights, biases, X_train, y_train)
        
        # 适应度与误差成反比
        fitness = 1 / (1 + mse)
        return fitness
    
    def forward_pass(self, weights, biases, X, y):
        """神经网络前向传播计算均方误差"""
        # 实现标准的前向传播过程
        activation = X.T
        for i in range(len(weights)):
            z = np.dot(weights[i], activation) + biases[i].reshape(-1, 1)
            activation = self.sigmoid(z)
        
        predictions = activation.flatten()
        mse = np.mean((predictions - y) ** 2)
        return mse
    
    def sigmoid(self, x):
        """Sigmoid激活函数"""
        return 1 / (1 + np.exp(-np.clip(x, -250, 250)))

def aco_bp_optimize(self, X_train, y_train, n_ants=50, n_iterations=100, 
                   alpha=1.0, beta=2.0, rho=0.5, Q=100):
    """
    蚁群算法优化BP神经网络
    参数:
        n_ants: 蚂蚁数量
        n_iterations: 迭代次数
        alpha: 信息素重要程度
        beta: 启发式信息重要程度
        rho: 信息素挥发系数
        Q: 信息素常数
    """
    # 初始化参数范围
    param_range = [-2, 2]  # 权重初始化范围
    
    # 初始化信息素矩阵
    pheromone = np.ones((n_ants, self.param_count))
    
    # 初始化蚂蚁位置
    ants_position = np.random.uniform(param_range[0], param_range[1], 
                                    (n_ants, self.param_count))
    
    best_fitness = -np.inf
    best_solution = None
    fitness_history = []
    
    for iteration in range(n_iterations):
        fitness_values = []
        
        # 评估每只蚂蚁的适应度
        for i in range(n_ants):
            fitness = self.fitness_function(ants_position[i], X_train, y_train)
            fitness_values.append(fitness)
            
            # 更新全局最优
            if fitness > best_fitness:
                best_fitness = fitness
                best_solution = ants_position[i].copy()
        
        fitness_history.append(best_fitness)
        
        # 更新信息素
        pheromone = (1 - rho) * pheromone  # 信息素挥发
        
        # 根据适应度增强优秀路径的信息素
        for i in range(n_ants):
            delta_pheromone = Q * fitness_values[i]
            pheromone[i] += delta_pheromone
        
        # 蚂蚁根据信息素选择新路径
        for i in range(n_ants):
            for j in range(self.param_count):
                # 计算选择概率
                probabilities = pheromone[:, j] ** alpha * (1.0 / (1 + np.abs(ants_position[:, j]))) ** beta
                probabilities = probabilities / np.sum(probabilities)
                
                # 轮盘赌选择
                selected_ant = np.random.choice(n_ants, p=probabilities)
                ants_position[i, j] = ants_position[selected_ant, j]
                
                # 添加随机扰动
                ants_position[i, j] += np.random.normal(0, 0.1)
                ants_position[i, j] = np.clip(ants_position[i, j], param_range[0], param_range[1])
        
        print(f"Iteration {iteration+1}/{n_iterations}, Best Fitness: {best_fitness:.6f}")
    
    return best_solution, fitness_history

def hybrid_optimization(self, X_train, y_train):
    """混合优化：ACO进行粗调，BP进行精调"""
    # 阶段1：ACO全局搜索
    best_solution, history = self.aco_bp_optimize(X_train, y_train, 
                                                 n_iterations=50)
    
    # 阶段2：BP局部精细调整
    fine_tuned_solution = self.bp_fine_tune(best_solution, X_train, y_train)
    
    return fine_tuned_solution

def adaptive_parameters(self, iteration, max_iterations):
    """自适应调整蚁群参数"""
    # 迭代初期：注重探索
    # 迭代后期：注重利用
    current_rho = 0.1 + 0.4 * (iteration / max_iterations)  # 挥发系数逐渐增大
    current_beta = 3.0 - 1.5 * (iteration / max_iterations)  # 启发式因子逐渐减小
    
    return current_rho, current_beta

# 生成训练数据：逼近 y = sin(x) + 0.5*cos(2x)
X = np.linspace(0, 2*np.pi, 100)
y = np.sin(X) + 0.5 * np.cos(2*X)
​
# 创建ACO-BP网络
network = ACO_BP_Network([1, 10, 1])  # 1输入，10隐藏节点，1输出
​
# 优化训练
best_weights, history = network.aco_bp_optimize(X.reshape(-1, 1), y, 
                                               n_ants=30, n_iterations=100)
​
# 测试性能
final_weights, final_biases = network.ant_to_network(best_weights)
predictions = network.predict(final_weights, final_biases, X.reshape(-1, 1))