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

1次阅读

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

BP 神经网络（Backpropagation Neural Network）和粒子群优化算法（Particle Swarm Optimization, PSO）是机器学习中常用的两种算法。BP 神经网络是一种多层前馈神经网络，通过反向传播算法调整权重，适用于分类和回归问题。粒子群优化算法则是一种群体智能优化算法，模拟鸟群觅食行为，常用于优化问题。

BP 神经网络 ：常用于图像识别、语音识别、金融预测等领域。
粒子群优化算法 ：常用于函数优化、参数调优、组合优化等问题。

优点：
能够处理非线性问题。
适用于大规模数据集。
缺点：
训练速度慢，容易陷入局部最优。
需要大量数据和计算资源。

优点：
实现简单，收敛速度快。
适用于高维优化问题。
缺点：
容易早熟收敛，陷入局部最优。
对参数设置敏感。

import numpy as np

class BPNeuralNetwork:
    def __init__(self, input_size, hidden_size, output_size):
        self.weights1 = np.random.randn(input_size, hidden_size)
        self.weights2 = np.random.randn(hidden_size, output_size)

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

    def forward(self, X):
        self.hidden = self.sigmoid(np.dot(X, self.weights1))
        self.output = self.sigmoid(np.dot(self.hidden, self.weights2))
        return self.output

    def backward(self, X, y, learning_rate):
        output_error = y - self.output
        output_delta = output_error * (self.output * (1 - self.output))

        hidden_error = np.dot(output_delta, self.weights2.T)
        hidden_delta = hidden_error * (self.hidden * (1 - self.hidden))

        self.weights2 += learning_rate * np.dot(self.hidden.T, output_delta)
        self.weights1 += learning_rate * np.dot(X.T, hidden_delta)

# 示例使用
X = np.array([[0, 0], [0, 1], [1, 0], [1, 1]])
y = np.array([[0], [1], [1], [0]])

nn = BPNeuralNetwork(2, 4, 1)
for i in range(10000):
    nn.forward(X)
    nn.backward(X, y, 0.1)

print(nn.forward(X))

import numpy as np

class PSO:
    def __init__(self, num_particles, num_dimensions, max_iter):
        self.num_particles = num_particles
        self.num_dimensions = num_dimensions
        self.max_iter = max_iter
        self.particles = np.random.rand(num_particles, num_dimensions)
        self.velocities = np.random.rand(num_particles, num_dimensions)
        self.best_positions = self.particles.copy()
        self.best_fitness = np.array([float('inf')] * num_particles)
        self.global_best_position = None
        self.global_best_fitness = float('inf')

    def fitness(self, position):
        return np.sum(position ** 2)  # 示例：最小化平方和

    def optimize(self):
        for _ in range(self.max_iter):
            for i in range(self.num_particles):
                current_fitness = self.fitness(self.particles[i])
                if current_fitness < self.best_fitness[i]:
                    self.best_fitness[i] = current_fitness
                    self.best_positions[i] = self.particles[i].copy()
                    if current_fitness < self.global_best_fitness:
                        self.global_best_fitness = current_fitness
                        self.global_best_position = self.particles[i].copy()

            for i in range(self.num_particles):
                inertia = 0.5
                cognitive = 1.5 * np.random.rand() * (self.best_positions[i] - self.particles[i])
                social = 1.5 * np.random.rand() * (self.global_best_position - self.particles[i])
                self.velocities[i] = inertia * self.velocities[i] + cognitive + social
                self.particles[i] += self.velocities[i]

        return self.global_best_position, self.global_best_fitness

# 示例使用
pso = PSO(30, 2, 100)
best_position, best_fitness = pso.optimize()
print(f"Best position: {best_position}, Best fitness: {best_fitness}")