神经网络与深度学习基础教程笔记(附案例讲解)

神经网络与深度学习基础教程笔记(附案例讲解)

引言

神经网络和深度学习是人工智能领域中最重要的技术之一，它们在图像识别、自然语言处理、语音识别等领域取得了巨大的成功。本教程将从基础概念出发，逐步深入到高级主题，帮助你全面理解并掌握这些强大的工具。本文是神经网络与深度学习笔记，要想深入了解相关理论和算法知识请参考神经网络从入门到精通、matlab从入门到精通教程、matlab2020从入门到精通、ACM入门教程资料、MATLAB语言常用算法程序集、matlab通俗讲讲“小波变换”、精通MATLAB最优化计算源码、MATLAB小波分析高级技术、基于MATLAB的系统分析与设计-小波分析、小波分析基础、时间序列的小波分析。

1. 神经网络基础

什么是神经网络？

神经网络是一种模拟人脑神经元结构的计算模型。它由多个节点（或称为神经元）组成，这些节点通过连接权重相互连接。每个节点接收输入信号，经过处理后传递给下一层节点。神经网络通过调整连接权重来学习数据中的模式。

感知机

感知机是最简单的神经网络形式，由 Frank Rosenblatt 在 1957 年提出。它只有一个输入层和一个输出层，没有隐藏层。感知机用于解决二分类问题。

数学表示：
$y=f({\sum }_{i=1}^n{w}_i{x}_i+b)$
其中，( y ) 是输出，( w_i ) 是权重，( x_i ) 是输入，( b ) 是偏置项，( f ) 是激活函数（通常是阶跃函数）。

训练过程：

• 初始化权重 ( w_i ) 和偏置 ( b )。
• 对于每个训练样本，计算输出 ( y )。
• 如果预测错误，更新权重和偏置：
  $w_i=w_i+\eta (t-y)x_i$
  $b=b+\eta (t-y)$
  其中，( \eta ) 是学习率，( t ) 是目标值。

多层感知机（MLP）

多层感知机（MLP）是包含一个或多个隐藏层的前馈神经网络。每个隐藏层可以有多个神经元，每个神经元都使用非线性激活函数（如 Sigmoid 或 ReLU）。

结构：

• 输入层：接收原始数据。
• 隐藏层：对数据进行特征提取。
• 输出层：产生最终结果。

数学表示：
假设有一个 MLP，输入层有 ( n ) 个节点，第一个隐藏层有 ( h_1 ) 个节点，第二个隐藏层有 ( h_2 ) 个节点，输出层有 ( m ) 个节点。

对于第 ( l ) 层的第 ( j ) 个节点：
$z_j^{(l)}={\sum }_{i=1}^{n_l}{w}_{ij}^{(l)}{a}_i^{(l-1)}+b_j^{(l)}$
$a_j^{(l)}=f(z_j^{(l)})$

其中，( z_j^{(l)} ) 是加权输入，( a_j^{(l)} ) 是激活值，( w_{ij}^{(l)} ) 是从第 ( l-1 ) 层的第 ( i ) 个节点到第 ( l ) 层的第 ( j ) 个节点的权重，( b_j^{(l)} ) 是偏置项，( f ) 是激活函数。

2. 激活函数

激活函数为神经网络引入非线性，使得网络能够学习复杂的模式。常见的激活函数包括：

• Sigmoid 函数：
  $f(x)=\frac{1}{1+e^{-x}}$

  • 输出范围：(0, 1)
  • 缺点：容易导致梯度消失。

• Tanh 函数：
  $f(x)=\tanh (x)=\frac{e^x-e^{-x}}{e^x+e^{-x}}$

  • 输出范围：(-1, 1)
  • 缺点：同样容易导致梯度消失。

• ReLU 函数：
  $f(x)=\max (0,x)$

  • 输出范围：[0, +∞)
  • 优点：计算简单，有效缓解梯度消失问题。

• Leaky ReLU 函数：
  $f(x)=\{\begin{array}{ll}x& \text{if }x>0\\ \alpha x& \text{if }x\le 0\end{array}$

  • 输出范围：(-∞, +∞)
  • 优点：解决了 ReLU 的“死神经元”问题。

• Softmax 函数：
  $\text{softmax}(z{)}_i=\frac{e^{z_i}}{{\sum }_{j=1}^K{e}^{z_j}}$

  • 输出范围：(0, 1)
  • 通常用于多分类任务的输出层，确保输出的概率之和为 1。

3. 损失函数

损失函数衡量模型预测值与真实值之间的差异。常见的损失函数包括：

• 均方误差（MSE）：
  $L=\frac{1}{N}{\sum }_{i=1}^N(y_i-{\hat{y}}_i{)}^2$

  • 适用于回归任务。

• 交叉熵损失（Cross-Entropy Loss）：
  $L=-\frac{1}{N}{\sum }_{i=1}^N\left[y_i\log ({\hat{y}}_i)+(1-y_i)\log (1-{\hat{y}}_i)\right]$

  • 适用于二分类任务。

• 多类交叉熵损失（Categorical Cross-Entropy Loss）：
  $L=-\frac{1}{N}{\sum }_{i=1}^N{\sum }_{k=1}^K{y}_{ik}\log ({\hat{y}}_{ik})$

  • 适用于多分类任务。

4. 优化算法

优化算法用于更新神经网络的权重，以最小化损失函数。常见的优化算法包括：

• 梯度下降法（Gradient Descent, GD）：
  $w_{t+1}=w_t-\eta \nabla L(w_t)$

  • 优点：简单直观。
  • 缺点：收敛速度慢，容易陷入局部极小值。

• 随机梯度下降法（Stochastic Gradient Descent, SGD）：
  $w_{t+1}=w_t-\eta \nabla L(w_t;x_i,y_i)$

  • 优点：每次只用一个样本更新权重，速度快。
  • 缺点：参数更新不稳定，可能不收敛。

• Mini-Batch 梯度下降法：
  $w_{t+1}=w_t-\eta \nabla L(w_t;X_b,Y_b)$

  • 优点：结合了批量梯度下降和随机梯度下降的优点。
  • 缺点：需要选择合适的批大小。

• 动量法（Momentum）：
  $v_{t+1}=\gamma v_t+\eta \nabla L(w_t)$
  $w_{t+1}=w_t-v_{t+1}$

  • 优点：加速收敛，减少振荡。

• Adagrad：
  $G_t={\sum }_{\tau =1}^t{g}_{\tau }{g}_{\tau }^T$
  $w_{t+1}=w_t-\frac{\eta }{\sqrt{\text{diag}(G_t)+ϵ}}\odot g_t$

  • 优点：自适应学习率，适合稀疏数据。

• RMSProp：
  $E[g^2{]}_t=\gamma E[g^2{]}_{t-1}+(1-\gamma )g_t^2$
  $w_{t+1}=w_t-\frac{\eta }{\sqrt{E[g^2{]}_t+ϵ}}{g}_t$

  • 优点：改进了 Adagrad 的单调递减学习率问题。

• Adam（Adaptive Moment Estimation）：
  $m_t={\beta }_1{m}_{t-1}+(1-{\beta }_1)g_t$
  $v_t={\beta }_2{v}_{t-1}+(1-{\beta }_2)g_t^2$
  ${\hat{m}}_t=\frac{m_t}{1-{\beta }_1^t}$
  ${\hat{v}}_t=\frac{v_t}{1-{\beta }_2^t}$
  $w_{t+1}=w_t-\frac{\eta }{\sqrt{{\hat{v}}_t}+ϵ}{\hat{m}}_t$

  • 优点：结合了动量法和 RMSProp 的优点，收敛速度快且稳定。

5. 反向传播算法

反向传播算法（Backpropagation）是神经网络中最常用的训练方法，它通过计算损失函数对各层权重的梯度来更新权重。具体步骤如下：

1. 前向传播：

   • 计算每一层的激活值 ( a^{(l)} ) 和加权输入 ( z^{(l)} )。
   • 计算最终的损失 ( L )。

2. 反向传播：

   • 计算输出层的误差 ( \delta^{(L)} )：
     ${\delta }^{(L)}={\nabla }_{a}C\odot {\sigma }^{\prime }(z^{(L)})$
     其中，( \nabla_a C ) 是损失函数对输出层激活值的梯度，( \sigma’ ) 是激活函数的导数。
   • 逐层向前计算每层的误差 ( \delta^{(l)} )：
     ${\delta }^{(l)}=((W^{(l+1)}{)}^T{\delta }^{(l+1)})\odot {\sigma }^{\prime }(z^{(l)})$
   • 计算权重的梯度 ( \nabla W^{(l)} ) 和偏置的梯度 ( \nabla b^{(l)} )：
     $\nabla W^{(l)}={\delta }^{(l)}(a^{(l-1)}{)}^T$
     $\nabla b^{(l)}={\delta }^{(l)}$

3. 权重更新：

   • 使用优化算法更新权重和偏置。

6. 卷积神经网络（CNN）

卷积神经网络（Convolutional Neural Network, CNN）主要用于处理具有空间层次结构的数据，如图像。CNN 包含以下关键组件：

• 卷积层（Convolutional Layer）：

  • 使用卷积核（滤波器）对输入数据进行卷积操作，提取局部特征。
  • 参数共享：同一滤波器在整个输入上共享相同的权重。

• 激活函数：

  • 通常使用 ReLU 激活函数。

• 池化层（Pooling Layer）：

  • 通过降维操作（如最大池化或平均池化）减少特征图的空间尺寸，提高平移不变性。

• 全连接层（Fully Connected Layer）：

  • 将卷积层和池化层提取的特征整合成最终的输出。

• Dropout 层：

  • 通过随机丢弃一部分神经元来防止过拟合。

典型架构：

• LeNet-5
• AlexNet
• VGGNet
• GoogLeNet/Inception
• ResNet

7. 循环神经网络（RNN）

循环神经网络（Recurrent Neural Network, RNN）用于处理序列数据，如文本、时间序列等。RNN 通过引入循环连接来保留先前时间步的信息。

基本结构：

• 每个时间步的输入 ( x_t ) 与前一时间步的隐藏状态 ( h_{t-1} ) 结合，生成当前时间步的隐藏状态 ( h_t ) 和输出 ( y_t )。
• 更新公式：
  $h_t=f(W_{hx}{x}_t+W_{hh}{h}_{t-1}+b_h)$
  $y_t=g(W_{hy}{h}_t+b_y)$
  其中，( f ) 和 ( g ) 是激活函数，( W ) 和 ( b ) 是权重和偏置。

常见变体：

• 长短时记忆网络（LSTM）：

  • 解决了传统 RNN 的梯度消失和梯度爆炸问题。
  • 通过引入细胞状态和门控机制来控制信息的流动。

• 门控循环单元（GRU）：

  • 简化了 LSTM 的结构，合并了遗忘门和输入门。

8. 长短期记忆网络（LSTM）

LSTM 是一种特殊的 RNN，通过引入细胞状态和门控机制来更好地处理长期依赖问题。

基本结构：

• 输入门：决定哪些信息需要更新到细胞状态。
• 遗忘门：决定哪些信息需要从细胞状态中丢弃。
• 输出门：决定哪些信息需要作为输出。

更新公式：

• 输入门：
  $i_t=\sigma (W_{xi}{x}_t+W_{hi}{h}_{t-1}+b_i)$
• 遗忘门：
  $f_t=\sigma (W_{xf}{x}_t+W_{hf}{h}_{t-1}+b_f)$
• 细胞状态更新：
  ${\tilde{C}}_t=\tanh (W_{xc}{x}_t+W_{hc}{h}_{t-1}+b_c)$
  $C_t=f_t\odot C_{t-1}+i_t\odot {\tilde{C}}_t$
• 输出门：
  $o_t=\sigma (W_{xo}{x}_t+W_{ho}{h}_{t-1}+b_o)$
• 输出隐藏状态：
  $h_t=o_t\odot \tanh (C_t)$

9. 生成对抗网络（GAN）

生成对抗网络（Generative Adversarial Networks, GAN）是一种无监督学习方法，用于生成新的数据实例。GAN 由两个部分组成：生成器（Generator）和判别器（Discriminator）。

工作原理：

• 生成器：生成新的数据实例，试图欺骗判别器认为这些实例是真实的。
• 判别器：区分生成的数据和真实数据。

训练过程：

• 生成器的目标是最小化判别器的正确率。
• 判别器的目标是最大化其正确率，即正确区分生成的数据和真实数据。

损失函数：

• 生成器的损失：
  $L_G=-{\mathbb{E}}_{z\sim p_z(z)}[\log (D(G(z)))]$
• 判别器的损失：
  $L_D=-{\mathbb{E}}_{x\sim p_{data}(x)}[\log (D(x))]-{\mathbb{E}}_{z\sim p_z(z)}[\log (1-D(G(z)))]$

10. 迁移学习

迁移学习是指将在一个任务上学到的知识迁移到另一个相关任务上。这种方法可以显著减少新任务所需的数据量和训练时间。

应用场景：

• 图像分类：预训练的 CNN 模型（如 VGG、ResNet）可以在新数据集上微调。
• 自然语言处理：预训练的语言模型（如 BERT、GPT）可以在特定任务上进行微调。

步骤：

1. 加载预训练模型：加载在大规模数据集上预训练的模型。
2. 冻结部分层：冻结预训练模型的部分层，防止其权重被更新。
3. 添加新层：根据新任务的需求，在预训练模型的基础上添加新的层。
4. 微调：在新数据集上进行训练，更新新层和未冻结的旧层的权重。

11. 实战项目：手写数字识别

下面是一个使用 TensorFlow 和 Keras 实现的手写数字识别项目的示例代码。

数据准备

我们将使用 MNIST 数据集，这是一个常用的手写数字数据集。

import tensorflow as tf
from tensorflow.keras import datasets, layers, models
import matplotlib.pyplot as plt

# 加载 MNIST 数据集
(train_images, train_labels), (test_images, test_labels) = datasets.mnist.load_data()

# 归一化像素值到 [0, 1] 范围
train_images, test_images = train_images / 255.0, test_images / 255.0

# 增加颜色通道维度
train_images = train_images[..., tf.newaxis]
test_images = test_images[..., tf.newaxis]

# 查看数据
print("Train images shape:", train_images.shape)
print("Train labels shape:", train_labels.shape)
print("Test images shape:", test_images.shape)
print("Test labels shape:", test_labels.shape)

# 显示一些样本
plt.figure(figsize=(10, 10))
for i in range(25):
    plt.subplot(5, 5, i + 1)
    plt.xticks([])
    plt.yticks([])
    plt.grid(False)
    plt.imshow(train_images[i], cmap=plt.cm.binary)
    plt.xlabel(train_labels[i])
plt.show()

构建模型

我们构建一个简单的卷积神经网络（CNN）。

model = models.Sequential([
    layers.Conv2D(32, (3, 3), activation='relu', input_shape=(28, 28, 1)),
    layers.MaxPooling2D((2, 2)),
    layers.Conv2D(64, (3, 3), activation='relu'),
    layers.MaxPooling2D((2, 2)),
    layers.Conv2D(64, (3, 3), activation='relu'),
    layers.Flatten(),
    layers.Dense(64, activation='relu'),
    layers.Dense(10, activation='softmax')
])

# 打印模型概要
model.summary()

编译模型

配置模型的优化器、损失函数和评估指标。

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

训练模型

训练模型并在测试集上进行评估。

history = model.fit(train_images, train_labels, epochs=10,
                    validation_data=(test_images, test_labels))

# 评估模型
test_loss, test_acc = model.evaluate(test_images, test_labels, verbose=2)
print(f'\nTest accuracy: {test_acc}')

可视化训练过程

绘制训练和验证的准确率和损失曲线。

import matplotlib.pyplot as plt

# 绘制训练和验证的准确率
plt.plot(history.history['accuracy'], label='accuracy')
plt.plot(history.history['val_accuracy'], label='val_accuracy')
plt.xlabel('Epoch')
plt.ylabel('Accuracy')
plt.ylim([0, 1])
plt.legend(loc='lower right')
plt.show()

# 绘制训练和验证的损失
plt.plot(history.history['loss'], label='loss')
plt.plot(history.history['val_loss'], label='val_loss')
plt.xlabel('Epoch')
plt.ylabel('Loss')
plt.legend(loc='upper right')
plt.show()

保存和加载模型

保存训练好的模型，并在需要时加载。

# 保存模型
model.save('mnist_model.h5')

# 加载模型
loaded_model = tf.keras.models.load_model('mnist_model.h5')

预测

使用加载的模型进行预测。

predictions = loaded_model.predict(test_images)

# 显示预测结果
def plot_image(i, predictions_array, true_label, img):
    predictions_array, true_label, img = predictions_array[i], true_label[i], img[i]
    plt.grid(False)
    plt.xticks([])
    plt.yticks([])

    plt.imshow(img, cmap=plt.cm.binary)

    predicted_label = np.argmax(predictions_array)
    if predicted_label == true_label:
        color = 'blue'
    else:
        color = 'red'

    plt.xlabel(f"{predicted_label} ({100 * np.max(predictions_array):.2f}%)", color=color)

def plot_value_array(i, predictions_array, true_label):
    predictions_array, true_label = predictions_array[i], true_label[i]
    plt.grid(False)
    plt.xticks([])
    plt.yticks([])
    thisplot = plt.bar(range(10), predictions_array, color="#777777")
    plt.ylim([0, 1])
    predicted_label = np.argmax(predictions_array)

    thisplot[predicted_label].set_color('red')
    thisplot[true_label].set_color('blue')

num_rows = 5
num_cols = 3
num_images = num_rows * num_cols
plt.figure(figsize=(2 * 2 * num_cols, 2 * num_rows))
for i in range(num_images):
    plt.subplot(num_rows, 2 * num_cols, 2 * i + 1)
    plot_image(i, predictions, test_labels, test_images)
    plt.subplot(num_rows, 2 * num_cols, 2 * i + 2)
    plot_value_array(i, predictions, test_labels)
plt.tight_layout()
plt.show()

总结

通过本教程，你应该已经掌握了神经网络和深度学习的基础知识，并了解了如何使用 TensorFlow 和 Keras 构建和训练一个简单的手写数字识别模型。你可以继续探索更多高级主题，如更复杂的网络架构、正则化技术、超参数调优等，以进一步提升你的技能。