原文链接：AI 基础知识从 0.2 到 0.3——构建你的第一个深度学习模型

AI 基础知识从 0.2 到 0.3——构建你的第一个深度学习模型

1. 深度学习是机器学习的分支，机器学习领域演化出深度学习，主要是因为传统机器学习在处理复杂、非结构化数据（如图像、音频、文本）时遇到了挑战，特别是传统机器方法需要大量人工设计特征，耗时且需要领域知识，模型难以捕捉数据中的深层关联。
2. 深度学习引入了深层神经网络、反向传播、卷积和循环网络等新思路，实现了从原始数据中自动提取层次化特征，极大减少了对人工特征工程的依赖。其在图像识别、语音识别、自然语言处理及生成任务中表现出色，尤其擅长处理非线性关系和大规模数据。

什么是深度学习

1. 深度学习核心是通过构建和训练多层神经网络（深度神经网络）模拟人脑的复杂决策能力，让计算机能够从大量数据中自主学习复杂的特征和规律，以处理和分析图像、语音、文本等非结构化数据。

3. 上图中展示了简单神经网络和深度神经网络，其中包含三个关键元素：

1. 节点：每个节点称为神经元，负责接收输入数据（通常为单一特征或特征组合），进行加权求和等运算，然后将结果传递给下一层的神经元。
2. 连线：神经元之间的连线代表信息传递的路径以及其权重。在训练过程中，这些连线负责传递信息，并使用权重来调整信号强度，以最小化预测误差。
3. 分层：神经元按功能纵向分层，每层与下一层全连接，形成输入层→隐藏层→输出层的架构。
   1. 输入层：负责接收数据输入，通常以特征形式呈现，每个神经元对应一个特征。
   2. 隐藏层：进行数据转换和特征提取，通过加权处理输入特征，生成更高层次的抽象特征。
   3. 输出层：生成预测结果，每个神经元对应一个输出变量。

使用深度学习识别手写数字

通过训练一个可以识别手写数字的模型来简单介绍深度学习的一些概念，我们的目标是训练一个深度神经网络模型，能够准确地识别手写数字。

准备数据

1. MNIST 是一个经典的手写数字识别数据集，包含了 60000 张训练图片和 10000 张测试图片，每张图片为 28x28 像素的灰度图像，代表数字 0 到 9。

数据处理

1. 对训练集的图像数据进行归一化处理，将每个像素值除以 255.0，得到每个像素值的范围在 0 - 1 之间的新数组，然后在训练集数据中拆出 10% 用于交叉验证的数据集。

定义模型

1. Keras 是一个高级神经网络 API，允许开发者通过简单的代码组合不同的神经网络层，快速、简洁地构建、训练和评估深度学习模型，目前已经被 Tensorflow 框架集成。
2. 每层中神经元的数据量：
   1. 输入层：根据数据特征数量设置神经元。例如 28x28 的图像展平后有 784 个特征，所以输入层有784个神经元。
   2. 隐藏层：神经元数量一般通过经验和试验确定，前层神经元数量相对较多，用于学习更具体的局部特征，后层减少神经元数量，迫使模型抽象特征，降低模型复杂度，减少过拟合风险。
   3. 输出层：输出层神经元的数量由具体的任务和输出的类别数量决定
      1. 分类任务：在多分类问题中输出层神经元的数量等于类别的数量。例如手写数字识别任务，要识别的数字有 0 - 9 共 10 个类别，所以输出层就设置 10 个神经元；
      2. 回归任务：输出层神经元的数量通常为 1 个。例如预测房价，只需要一个预测值，输出层就设置 1 个神经元；
3. 激活函数（Activation Function） 是神经网络中每个神经元输出时应用的非线性变换函数。它决定了一个神经元是否被激活，以及传递给下一个神经元的信息量。若没有激活函数，多层神经网络将退化为线性模型，无法学习复杂的非线性关系。有几个常用的激活函数：
   1. ReLU：输出范围在 [0, ∞) 之间，计算简单且高效，能够有效缓解梯度消失问题，是当前最常用的隐藏层激活函数。
   2. Sigmoid：输出范围在 (0, 1) 之间，将输入映射为 0 到 1 之间的概率值，常用于二分类问题的输出层。
   3. Softmax：每个元素在 (0, 1) 之间，且所有元素之和为 1，通常用于多分类任务的输出层，用于表示每个类别的概率。

训练模型

1. 首先对模型进行配置，确定模型在训练过程中所使用的优化器、损失函数和评估指标。

   ▼
   python
   复制代码
   model.compile(optimizer='adam',
                 loss='sparse_categorical_crossentropy',
                 metrics=['accuracy'])
   

   1. loss：在前面的章节接触过了 MSE 损失函数，sparse_categorical_crossentropy 适用于多分类问题，当标签是整数编码时使用。
   2. optimizer：优化器的作用是在训练过程中调整模型的参数，以最小化损失函数。常见的优化器有：
      1. Adam：综合性能较好，在很多场景下都能取得不错的效果，是一种常用的默认选择。
      2. SGD：随机梯度下降，是最基础的优化算法，每次迭代时随机选择小批样本计算梯度，根据梯度更新模型的参数，简单任务且数据量较大时可考虑。
      3. Adagrad：根据每个参数的历史梯度信息自适应地调整学习率，处理稀疏数据时效果较好。
      4. RMSProp：Adagrad 的改进，引入衰减系数，避免学习率单调递减的问题，大多数情况下表现良好，特别是在非凸优化问题中。
      5. Adadelta：无需手动设置学习率，适用于各种任务，尤其在数据量较大、模型较复杂的情况下表现较好。
   3. metrics：评估指标用于在训练和测试过程中监控模型的性能，可以帮助开发者了解模型在每个 epoch 训练后的表现。
2. 在每一轮训练中，训练数据会被分成多个批次，模型依次处理每个批次的数据，并根据该批次数据的梯度更新模型的参数。每一轮训练结束后，模型会使用验证数据进行评估，并输出验证集上的损失和评估指标。重复上述过程，直到达到指定的训练轮数。

评估模型

1. 使用测试数据集对已经训练好的模型进行评估，从而了解模型在未见过的数据上的性能表现。

进行预测

完整代码：

▼
python
复制代码
import tensorflow as tf
from tensorflow import keras
import numpy as np
import matplotlib.pyplot as plt
from sklearn.model_selection import train_test_split
# 加载 MNIST 手写数字数据集
mnist = keras.datasets.mnist
(train_images, train_labels), (test_images, test_labels) = mnist.load_data()
# 数据预处理，将像素归一化到 0-1 之间，提升训练效率
train_images = train_images / 255.0
test_images = test_images / 255.0
# 从训练集中划分出验证集，验证集占比 20%
train_images, val_images, train_labels, val_labels = train_test_split(
    train_images, train_labels, test_size=0.2, random_state=42)
# 定义模型
model = keras.Sequential([
    # 输入层，输入 28x28 的图像
    keras.Input(shape=(28, 28)),
    # 将 28x28 的图像展平为一维向量
    keras.layers.Flatten(),
    # 第一个隐藏层，有 128 个神经元，使用 ReLU 激活函数
    keras.layers.Dense(128, activation='relu'),
    # 第二个隐藏层，有 64 个神经元，使用 ReLU 激活函数
    keras.layers.Dense(64, activation='relu'),
    # 输出层，有 10 个神经元，对应 0 - 9 这 10 个数字类别，使用 softmax 激活函数
    keras.layers.Dense(10, activation='softmax')
])
# 训练模型
model.compile(optimizer='adam',
              loss='sparse_categorical_crossentropy',
              metrics=['accuracy'])
model.fit(
    train_images, train_labels, 
    epochs=5, batch_size=32,
    validation_data=(val_images, val_labels)
)
# 评估模型
test_loss, test_acc = model.evaluate(test_images, test_labels)
print(f'Test accuracy: {test_acc}')
# 进行预测
predictions = model.predict(test_images)
# 找出每个样本中概率最大的元素所在的索引，也就是预测的类别
predicted_labels = np.argmax(predictions, axis=1)
# 打印前 10 个样本的预测结果和真实标签
for i in range(10):
    print(f"样本 {i}：预测标签 = {predicted_labels[i]}, 真实标签 = {test_labels[i]}")
# 可视化预测结果
def plot_image(i, predictions_array, true_label, img):
    predictions_array, true_label, img = predictions_array, 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):2.0f}% ({true_label})",
               color=color)
def plot_value_array(i, predictions_array, true_label):
    predictions_array, true_label = predictions_array, true_label[i]
    plt.grid(False)
    plt.xticks(range(10))
    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')
# 显示前 15 个测试图像的预测结果
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[i], test_labels, test_images)
    plt.subplot(num_rows, 2 * num_cols, 2 * i + 2)
    plot_value_array(i, predictions[i], test_labels)
plt.tight_layout()
plt.show()

1. 这段代码使用了全连接神经网络（Fully Connected Neural Network）架构，也称为多层感知机（Multi-Layer Perceptron，MLP）。这是一个基础神经网络模型，没有使用卷积层或其它复杂结构，只使用了全连接层。
2. 如果使用 CNN 模型架构，核心代码大概是：

   ▼
   python
   复制代码
   # 定义 CNN 模型
   model = keras.Sequential([
       # 输入层，输入 28x28 的单通道图像，需要添加通道维度
       keras.Input(shape=(28, 28, 1)),
       # 第一个卷积层，有 32 个滤波器，卷积核大小为 3x3，使用 ReLU 激活函数
       keras.layers.Conv2D(32, kernel_size=(3, 3), activation='relu'),
       # 最大池化层，池化窗口大小为 2x2
       keras.layers.MaxPooling2D(pool_size=(2, 2)),
       # 第二个卷积层，有 64 个滤波器，卷积核大小为 3x3，使用 ReLU 激活函数
       keras.layers.Conv2D(64, kernel_size=(3, 3), activation='relu'),
       # 最大池化层，池化窗口大小为 2x2
       keras.layers.MaxPooling2D(pool_size=(2, 2)),
       # 将卷积层的输出展平为一维向量
       keras.layers.Flatten(),
       # 全连接层，有 128 个神经元，使用 ReLU 激活函数
       keras.layers.Dense(128, activation='relu'),
       # 输出层，有 10 个神经元，对应 0 - 9 这 10 个数字类别，使用 softmax 激活函数
       keras.layers.Dense(10, activation='softmax')
   ])
   

Transformer 与 Tensorflow

1. Transformer 是基于自注意力机制的神经网络架构，主要用于自然语言处理（NLP）等序列建模任务，本质上是一种解决问题的设计理念与方案。
2. TensorFlow 是由 Google 开发的开源机器学习框架 ，提供了丰富的工具和库来构建、训练和部署各种机器学习模型，本质上是一个工具实现。
3. 可以利用 TensorFlow 提供的操作、函数和类来实现 Transformer 架构，进行模型训练和推理。工程同学也能简单把 Transformer 和 Tensorflow 的关系理解为 MVC 架构与 Spring MVC 的关系。

Tensorflow 与 PyTorch

1. TensorFlow 与 PyTorch 是当前深度学习领域中最为流行的两个开源框架：
   1. TensorFlow 由 Google Brain 团队于 2015 年 11 月发布，原生支持分布式计算，适合大规模模型和数据的训练。在 TensorFlow 1.x 时代，静态计算图的概念对于初学者来说较为复杂。2017 年发布 TensorFlow 2.0，强调易用性与灵活性，集成了 Keras 高级 API，支持动态图模式，提高了用户体验。
   2. PyTorch 由 Facebook 于 2016 年 1 月发布，旨在为研究人员提供一个灵活且高效的深度学习框架。发布初版采用动态计算图，使得模型构建和调试过程更加直观和简便，尤其适合研究和快速原型开发。2018 年发布 PyTorch 1.0，标志着框架的成熟，增强了生产部署能力。
   3. 两者各有优势，TensorFlow 更加适合需要强大部署能力和完整生态系统的工业应用，而 PyTorch 则因其灵活性和易用性，深受研究人员和开发者的青睐，超过 80% 的新研究论文优先使用 PyTorch 实现，虽然文中示例主要是用 Tensorflow，但如果仅仅是想了解深度学习，建议使用 PyTorch。