深度学习入门：从零解析BP神经网络、卷积神经网络与循环神经网络

1次阅读

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

神经网络的发展可以追溯到 1943 年 McCulloch 和 Pitts 提出的 MP 模型。随着计算能力的提升和算法的改进，神经网络在近年来得到了广泛应用。BP 神经网络、卷积神经网络（CNN）和循环神经网络（RNN）是三种最基础的神经网络结构，各自适用于不同的场景：

BP 神经网络 ：全连接结构，适合处理结构化数据，如房价预测、信用评分等
CNN：擅长处理网格状数据（如图像），广泛应用于计算机视觉领域
RNN：具有记忆功能，适合处理序列数据（如文本、语音、时间序列）

BP（Back Propagation）神经网络是最基础的前馈神经网络，其核心是通过反向传播算法来调整网络权重。

前向传播 ：

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

反向传播 （以均方误差损失为例）：

输出层误差：

$$
\delta^{(L)} = \nabla_a J \odot f'(z^{(L)})
$$

隐藏层误差：

$$
\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)}
$$

CNN 通过三大核心思想解决了图像处理中的维度灾难问题：

局部连接 ：每个神经元只连接输入区域的局部感受野
权值共享 ：同一个卷积核在不同位置共享参数
池化（Pooling）：降低空间维度，增强平移不变性

典型的 CNN 层包括：

卷积层（Convolutional Layer）
激活层（常用 ReLU）
池化层（Max/Average Pooling）
全连接层（Fully Connected Layer）

RNN 通过引入循环连接处理序列数据，其基本结构为：

$$
h_t = f(W_{xh}x_t + W_{hh}h_{t-1} + b_h)
$$

$$
o_t = g(W_{ho}h_t + b_o)
$$

为解决长程依赖问题，LSTM 引入了三个门控机制：

遗忘门（Forget Gate）
输入门（Input Gate）
输出门（Output Gate）

import numpy as np

class NeuralNetwork:
    def __init__(self, layers):
        self.weights = [np.random.randn(y, x) * 0.1 
                        for x, y in zip(layers[:-1], layers[1:])]
        self.biases = [np.zeros((y, 1)) for y in layers[1:]]

    def forward(self, x):
        a = x
        for w, b in zip(self.weights, self.biases):
            z = np.dot(w, a) + b
            a = 1 / (1 + np.exp(-z))  # Sigmoid 激活
        return a

    def train(self, X, y, epochs, lr):
        for _ in range(epochs):
            # 前向传播
            # ... 省略反向传播实现...

import torch
import torch.nn as nn

class CNN(nn.Module):
    def __init__(self):
        super().__init__()
        self.conv1 = nn.Conv2d(1, 32, 3, 1)
        self.conv2 = nn.Conv2d(32, 64, 3, 1)
        self.fc1 = nn.Linear(9216, 128)
        self.fc2 = nn.Linear(128, 10)

    def forward(self, x):
        x = F.relu(self.conv1(x))
        x = F.max_pool2d(x, 2)
        x = F.relu(self.conv2(x))
        x = torch.flatten(x, 1)
        x = F.relu(self.fc1(x))
        return self.fc2(x)

import tensorflow as tf

model = tf.keras.Sequential([tf.keras.layers.Embedding(vocab_size, 256),
    tf.keras.layers.LSTM(1024, return_sequences=True),
    tf.keras.layers.Dense(vocab_size)
])

model.compile(optimizer='adam', 
              loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True))