从人工神经元到神经网络实战：前向传播与反向传播算法详解及实现

1次阅读

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

人工神经元是神经网络的基本单元，其数学模型模仿了生物神经元的工作原理。一个典型的人工神经元包含三个主要部分：

输入：接收来自其他神经元或外部环境的信号（x₁, x₂, …, xn）
权重：每个输入都有一个对应的权重（w₁, w₂, …, wn），表示该输入的重要性
激活函数：对加权和进行非线性变换的函数（如 Sigmoid、ReLU 等）

数学表达式为：

z = w₁x₁ + w₂x₂ + ... + wnxn + b
a = f(z)

其中 b 是偏置项，f 是激活函数。

前向传播是神经网络进行预测的核心过程，其步骤可以概括为：

输入数据通过输入层进入网络
每一层的神经元计算加权和并应用激活函数
结果传递到下一层，直到输出层产生最终预测

以一个简单的 3 层网络（输入层、隐藏层、输出层）为例：

输入层到隐藏层：

z^[1] = W^[1]X + b^[1]
a^[1] = f^[1](z^[1])

隐藏层到输出层：

z^[2] = W^[2]a^[1] + b^[2]
a^[2] = f^[2](z^[2])

反向传播（Backpropagation，简称 BP）是神经网络训练的核心算法，其目的是通过调整权重来最小化损失函数。BP 算法可以分为四个主要步骤：

前向传播 计算预测值和损失

计算输出层误差：

δ^[L] = ∂L/∂a^[L] ⊙ f'^[L](z^[L])

反向传播误差 到各层：

δ^[l] = (W^[l+1]T δ^[l+1]) ⊙ f'^[l](z^[l])

计算梯度并更新参数：

∂L/∂W^[l] = δ^[l] a^[l-1]T
∂L/∂b^[l] = δ^[l]
W^[l] = W^[l] - α ∂L/∂W^[l]
b^[l] = b^[l] - α ∂L/∂b^[l]

下面是一个简单的全连接神经网络的 Python 实现：

import numpy as np

class NeuralNetwork:
    def __init__(self, layer_sizes):
        self.weights = [np.random.randn(y, x) * 0.1 
                        for x, y in zip(layer_sizes[:-1], layer_sizes[1:])]
        self.biases = [np.zeros((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):
        # 前向传播
        activations = [x]
        zs = []
        for w, b in zip(self.weights, self.biases):
            z = np.dot(w, activations[-1]) + b
            zs.append(z)
            activations.append(self.sigmoid(z))

        # 反向传播
        delta = (activations[-1] - y) * self.sigmoid_prime(zs[-1])
        nabla_w = [np.zeros(w.shape) for w in self.weights]
        nabla_b = [np.zeros(b.shape) for b in self.biases]

        nabla_w[-1] = np.dot(delta, activations[-2].T)
        nabla_b[-1] = delta

        for l in range(2, len(self.weights)+1):
            z = zs[-l]
            sp = self.sigmoid_prime(z)
            delta = np.dot(self.weights[-l+1].T, delta) * sp
            nabla_w[-l] = np.dot(delta, activations[-l-1].T)
            nabla_b[-l] = delta

        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))

常见的激活函数包括：