当前位置：首页 > news >正文

【深度学习基础】神经网络入门：从感知机到反向传播

news 来源：原创 2025/6/15 13:05:57

摘要

神经网络是深度学习的核心！本文将带你从零开始理解神经网络的基本原理，包括感知机模型、激活函数选择、反向传播算法等核心概念，并通过Python实现一个简单的全连接神经网络。文末提供《神经网络公式推导手册》和实战项目资源包！

一、神经网络基础概念

1.1 感知机模型

感知机是最简单的神经网络单元，其数学表达式为：

$y = f(\sum_{i=1}^n w_i x_i + b)$

其中：

$x_i$ ：输入特征
$w_i$ ：权重参数
$b$ ：偏置项
$f$ ：激活函数

1.2 常用激活函数

函数名称	数学表达式	特点
Sigmoid	$\sigma(x) = \frac{1}{1+e^{-x}}$	输出范围(0,1)
ReLU	$f(x) = max(0,x)$	计算简单，缓解梯度消失
Tanh	$tanh(x) = \frac{e^x - e^{-x}}{e^x + e^{-x}}$	输出范围(-1,1)

二、前向传播与反向传播

2.1 前向传播过程

对于L层神经网络，第l层的输出为：

$a^{(l)} = f(z^{(l)}) = f(W^{(l)}a^{(l-1)} + b^{(l)})$

2.2 损失函数

常用交叉熵损失函数：
$J(W,b) = -\frac{1}{m}\sum_{i=1}^m [y^{(i)}\log(\hat{y}^{(i)}) + (1-y^{(i)})\log(1-\hat{y}^{(i)})]$

2.3 反向传播算法

关键梯度计算公式：

输出层误差：
$\delta^{(L)} = \hat{y} - y$
隐藏层误差：
$\delta^{(l)} = (W^{(l+1)})^T \delta^{(l+1)} \odot f'(z^{(l)})$
参数梯度：
$\frac{\partial J}{\partial W^{(l)}} = \delta^{(l)}(a^{(l-1)})^T$
$\frac{\partial J}{\partial b^{(l)}} = \delta^{(l)}$

三、Python实现全连接神经网络

import numpy as np

class NeuralNetwork:
    def __init__(self, layers, learning_rate=0.01):
        self.layers = layers  # 网络结构，如[2,4,1]
        self.lr = learning_rate
        self.weights = []
        self.biases = []
        
        # 初始化参数
        for i in range(len(layers)-1):
            self.weights.append(np.random.randn(layers[i+1], layers[i]) * 0.1)
            self.biases.append(np.zeros((layers[i+1], 1)))
    
    def sigmoid(self, x):
        return 1 / (1 + np.exp(-x))
    
    def sigmoid_derivative(self, x):
        return x * (1 - x)
    
    def forward(self, X):
        self.activations = [X.T]
        self.z_values = []
        
        for w, b in zip(self.weights, self.biases):
            z = np.dot(w, self.activations[-1]) + b
            self.z_values.append(z)
            self.activations.append(self.sigmoid(z))
        
        return self.activations[-1]
    
    def backward(self, X, y):
        m = X.shape[0]
        y = y.reshape(-1, 1).T
        
        # 计算输出层误差
        delta = (self.activations[-1] - y) * self.sigmoid_derivative(self.activations[-1])
        
        # 反向传播
        for l in range(len(self.layers)-2, 0, -1):
            self.weights[l] -= self.lr * np.dot(delta, self.activations[l].T) / m
            self.biases[l] -= self.lr * np.sum(delta, axis=1, keepdims=True) / m
            delta = np.dot(self.weights[l].T, delta) * self.sigmoid_derivative(self.activations[l])
        
        # 更新第一层参数
        self.weights[0] -= self.lr * np.dot(delta, self.activations[0].T) / m
        self.biases[0] -= self.lr * np.sum(delta, axis=1, keepdims=True) / m
    
    def train(self, X, y, epochs):
        for epoch in range(epochs):
            output = self.forward(X)
            self.backward(X, y)
            if epoch % 100 == 0:
                loss = -np.mean(y * np.log(output) + (1-y) * np.log(1-output))
                print(f"Epoch {epoch}, Loss: {loss:.4f}")

四、神经网络实战应用

4.1 异或问题求解

# 准备数据
X = np.array([[0,0], [0,1], [1,0], [1,1]])
y = np.array([[0], [1], [1], [0]])

# 创建网络
nn = NeuralNetwork(layers=[2,4,1], learning_rate=0.1)

# 训练网络
nn.train(X, y, epochs=5000)

# 测试效果
print("Predictions:")
for x in X:
    print(f"{x} -> {nn.forward(x.reshape(1,-1))[0,0]:.3f}")

4.2 手写数字识别（MNIST）

from tensorflow.keras.datasets import mnist
from tensorflow.keras.utils import to_categorical

# 加载数据
(X_train, y_train), (X_test, y_test) = mnist.load_data()
X_train = X_train.reshape(-1, 784) / 255.0
X_test = X_test.reshape(-1, 784) / 255.0
y_train = to_categorical(y_train)
y_test = to_categorical(y_test)

# 创建更大的网络
mnist_nn = NeuralNetwork(layers=[784, 128, 64, 10], learning_rate=0.01)

# 训练（实际应用中建议使用深度学习框架）
# mnist_nn.train(X_train, y_train, epochs=10)