bp前馈全连接神经网络：从数学原理到工程实现

1次阅读

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

前馈全连接神经网络（Fully Connected Feedforward Neural Network）是一种经典的深度学习模型。它的核心特点是信息单向流动，从输入层经过若干隐藏层最终到达输出层，没有反馈连接。这种结构非常适合处理分类和回归问题。

网络结构 ：由输入层、隐藏层和输出层组成
前向传播 ：数据从输入层流向输出层的过程
反向传播 ：误差从输出层反向传播到输入层的过程

反向传播（Backpropagation，BP）是神经网络训练的核心算法，它通过链式法则计算损失函数对每个参数的梯度。

定义损失函数 L(y, ŷ)
计算输出层误差 δ^L = ∇ŷL ⊙ σ'(z^L)
反向传播误差：δ^l = ((w^{l+1})^T δ^{l+1}) ⊙ σ'(z^l)
计算梯度：∇_{w^l}L = δ^l (a^{l-1})^T
参数更新：w^l ← w^l – η∇_{w^l}L

现象：深层网络中梯度呈指数级减小或增大
原因：激活函数导数小于 1 或权重初始化不当
解决方案 ：
使用 ReLU 及其变种激活函数
采用 Xavier 或 He 初始化
引入残差连接

现象：训练集表现好但测试集表现差
解决方案 ：
Dropout
L1/L2 正则化
早停法

import numpy as np

class NeuralNetwork:
    def __init__(self, layer_sizes):
        # 权重初始化
        self.weights = [np.random.randn(y, x)/np.sqrt(x) 
                        for x, y in zip(layer_sizes[:-1], layer_sizes[1:])]
        self.biases = [np.random.randn(y, 1) for y in layer_sizes[1:]]

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

    def backward(self, x, y):
        # 反向传播
        nabla_w = [np.zeros(w.shape) for w in self.weights]
        nabla_b = [np.zeros(b.shape) for b in self.biases]

        # 前向传播
        activation = x
        activations = [x]
        zs = []
        for w, b in zip(self.weights, self.biases):
            z = np.dot(w, activation) + b
            zs.append(z)
            activation = self.sigmoid(z)
            activations.append(activation)

        # 输出层误差
        delta = self.cost_derivative(activations[-1], y) * \
                self.sigmoid_prime(zs[-1])
        nabla_b[-1] = delta
        nabla_w[-1] = np.dot(delta, activations[-2].transpose())

        # 反向传播误差
        for l in range(2, len(self.weights)+1):
            z = zs[-l]
            sp = self.sigmoid_prime(z)
            delta = np.dot(self.weights[-l+1].transpose(), delta) * sp
            nabla_b[-l] = delta
            nabla_w[-l] = np.dot(delta, activations[-l-1].transpose())

        return (nabla_w, nabla_b)

    def sigmoid(self, z):
        return 1.0/(1.0+np.exp(-z))

    def sigmoid_prime(self, z):
        return self.sigmoid(z)*(1-self.sigmoid(z))

    def cost_derivative(self, output_activations, y):
        return (output_activations - y)