BP神经网络与粒子群优化算法入门指南：从理论到实践

1次阅读

共计 3353 个字符，预计需要花费 9 分钟才能阅读完成。

BP 神经网络（Back Propagation Neural Network）是一种常用的人工神经网络模型，它通过反向传播算法来调整网络权重，从而实现对复杂非线性关系的建模。BP 神经网络广泛应用于图像识别、语音识别、金融预测等领域。

粒子群优化算法（Particle Swarm Optimization, PSO）是一种基于群体智能的优化算法，模拟鸟群觅食行为，通过个体之间的信息共享来寻找最优解。PSO 常用于函数优化、参数调优等场景。

优点：
强大的非线性建模能力
能够处理高维数据
适用于大规模数据集
缺点：
训练时间长
容易陷入局部最优
对初始权重敏感

优点：
实现简单
收敛速度快
适用于连续优化问题
缺点：
对离散问题效果不佳
可能出现早熟收敛
参数设置对性能影响大

import numpy as np

class BPNeuralNetwork:
    def __init__(self, layers):
        self.layers = layers
        self.weights = []
        self.biases = []
        for i in range(len(layers)-1):
            # 初始化权重和偏置
            self.weights.append(np.random.randn(layers[i], layers[i+1]))
            self.biases.append(np.random.randn(layers[i+1]))

    def sigmoid(self, x):
        return 1/(1+np.exp(-x))

    def forward(self, x):
        """前向传播"""
        a = x
        for w, b in zip(self.weights, self.biases):
            z = np.dot(a, w) + b
            a = self.sigmoid(z)
        return a

    def train(self, X, y, epochs=1000, learning_rate=0.1):
        """训练网络"""
        for _ in range(epochs):
            # 前向传播
            a = X
            activations = [a]
            zs = []
            for w, b in zip(self.weights, self.biases):
                z = np.dot(a, w) + b
                zs.append(z)
                a = self.sigmoid(z)
                activations.append(a)

            # 反向传播
            delta = (activations[-1] - y) * activations[-1] * (1 - activations[-1])
            deltas = [delta]

            for i in range(len(self.weights)-1, 0, -1):
                delta = np.dot(deltas[-1], self.weights[i].T) * activations[i] * (1 - activations[i])
                deltas.append(delta)
            deltas.reverse()

            # 更新权重和偏置
            for i in range(len(self.weights)):
                self.weights[i] -= learning_rate * np.dot(activations[i].T, deltas[i])
                self.biases[i] -= learning_rate * np.sum(deltas[i], axis=0)

import numpy as np

class PSO:
    def __init__(self, objective_func, dim, n_particles=30, w=0.5, c1=1.5, c2=1.5):
        self.objective_func = objective_func
        self.dim = dim
        self.n_particles = n_particles
        self.w = w  # 惯性权重
        self.c1 = c1  # 个体学习因子
        self.c2 = c2  # 社会学习因子

        # 初始化粒子位置和速度
        self.positions = np.random.uniform(-10, 10, (n_particles, dim))
        self.velocities = np.random.uniform(-1, 1, (n_particles, dim))

        # 初始化个体最优和全局最优
        self.pbest_positions = self.positions.copy()
        self.pbest_values = np.array([objective_func(p) for p in self.positions])
        self.gbest_position = self.pbest_positions[np.argmin(self.pbest_values)]
        self.gbest_value = np.min(self.pbest_values)

    def update(self):
        """更新粒子位置和速度"""
        r1 = np.random.rand(self.n_particles, self.dim)
        r2 = np.random.rand(self.n_particles, self.dim)

        # 更新速度
        cognitive = self.c1 * r1 * (self.pbest_positions - self.positions)
        social = self.c2 * r2 * (self.gbest_position - self.positions)
        self.velocities = self.w * self.velocities + cognitive + social

        # 更新位置
        self.positions += self.velocities

        # 评估新位置
        current_values = np.array([self.objective_func(p) for p in self.positions])

        # 更新个体最优
        improved_indices = current_values < self.pbest_values
        self.pbest_positions[improved_indices] = self.positions[improved_indices]
        self.pbest_values[improved_indices] = current_values[improved_indices]

        # 更新全局最优
        if np.min(current_values) < self.gbest_value:
            self.gbest_position = self.positions[np.argmin(current_values)]
            self.gbest_value = np.min(current_values)

    def optimize(self, max_iter=100):
        """运行优化"""
        for _ in range(max_iter):
            self.update()
        return self.gbest_position, self.gbest_value