AI 基础知识从 0.2 到 0.3——初识深度学习

深度学习是机器学习的分支，机器学习领域演化出深度学习，主要是因为传统机器学习在处理复杂、非结构化数据（如图像、音频、文本）时遇到了挑战，特别是传统机器方法需要大量人工设计特征，耗时且需要领域知识，模型难以捕捉数据中的深层关联。

深度学习引入了深层神经网络、反向传播、卷积和循环网络等新思路，实现了从原始数据中自动提取层次化特征，极大减少了对人工特征工程的依赖。其在图像识别、语音识别、自然语言处理及生成任务中表现出色，尤其擅长处理非线性关系和大规模数据。

随着互联网和传感器技术的发展，海量标注数据涌现，同时 GPU 和分布式计算技术的成熟，为训练深层神经网络提供了算力支持，使得处理大规模数据的复杂模型成为可能。

什么是深度学习

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

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

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

由于深度学习有非常多新的概念，接下来我们通过训练一个可以识别手写数字的模型来简单介绍深度学习的一些概念。

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

我们的目标是训练一个深度神经网络模型，能够准确地识别手写数字。

准备数据

TensorFlow 是由 Google 开发的开源机器学习框架，提供了丰富的工具和库来构建、训练和部署各种机器学习模型，本质上是一个工具包。

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

MNIST 手写数字数据集通过 Keras 直接加载，当首次运行这段代码时，TensorFlow 会自动下载 MNIST 数据集并缓存到系统的默认缓存目录，下载之后，数据直接加载到内存中

MNIST 数据集是一个拓展名为.npz 的NumPy 的压缩数据格式文件，不能用常规解压软件直接解压查看，可以通过一段简单代码查看其内容

python 复制代码

import numpy as np
import os
import matplotlib.pyplot as plt

# 加载mnist.npz文件
mnist_path = os.path.expanduser('~/.keras/datasets/mnist.npz')
data = np.load(mnist_path)

# 显示数据集包含的数组
print("MNIST 数据集包含以下数组:")
print(data.files)

# 提取数据
x_train = data['x_train']
y_train = data['y_train']
x_test = data['x_test']
y_test = data['y_test']

# 显示数据形状
print(f"\n训练图像: {x_train.shape}, 类型: {x_train.dtype}")
print(f"训练标签: {y_train.shape}, 类型: {y_train.dtype}")
print(f"测试图像: {x_test.shape}, 类型: {x_test.dtype}")
print(f"测试标签: {y_test.shape}, 类型: {y_test.dtype}")

# 显示几张图像示例
plt.rcParams['font.family'] = 'SimSong'
plt.figure(figsize=(10, 5))
for i in range(10):
    plt.subplot(2, 5, i+1)
    plt.imshow(x_train[i], cmap='gray')
    plt.title(f"标签: {y_train[i]}")
    plt.axis('off')
plt.tight_layout()
plt.savefig('mnist_samples.png')  # 保存图像到文件
print("\n已保存10张示例图像到 mnist_samples.png")

# 将部分数据保存为普通图像文件
output_dir = 'mnist_extracted'
if not os.path.exists(output_dir):
    os.makedirs(output_dir)

# 保存前20张训练图像
for i in range(20):
    img_path = f"{output_dir}/train_{i}_label_{y_train[i]}.png"
    plt.imsave(img_path, x_train[i], cmap='gray')

print(f"\n已提取20张训练图像到 {output_dir} 目录")

plain 复制代码

MNIST 数据集包含以下数组:
['x_train', 'x_test', 'y_train', 'y_test']

训练图像: (60000, 28, 28), 类型: uint8
训练标签: (60000,), 类型: uint8
测试图像: (10000, 28, 28), 类型: uint8
测试标签: (10000,), 类型: uint8

数据处理

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

python 复制代码

# 数据预处理，将像素归一化到 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)

定义模型

接下来我们利用 Keras 可以定义深度神经网络模型了，Keras 是一个高级神经网络 API，允许开发者通过简单的代码组合不同的神经网络层，快速、简洁地构建、训练和评估深度学习模型，目前已经被 Tensorflow 框架集成。

python 复制代码

# 定义模型
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')
])

keras.Sequential() 用于创建顺序模型，顺序模型中各层会按照添加的顺序依次执行，前一层的输出会作为后一层的输入。
keras.Input() 函数用于定义输入层，shape=(28, 28) 表示输入数据是 28 像素宽、28 像素高的二维图像。
keras.layers.Flatten() 是一个扁平化层，由于后续的全连接层（Dense 层）要求输入为一维向量，而输入的图像是 28x28 的二维矩阵，所以该层的作用是将 28x28 的二维图像数据 "展平" 成一个长度为 28 * 28 = 784 的一维向量。
keras.layers.Dense() 用于创建全连接层
- 128 表示该层包含 128 个神经元。每个神经元会接收上一层的输入，并对这些输入进行加权求和，然后通过激活函数处理后输出。
- activation 用来指定了该层使用的激活函数，ReLU、softmax 都是激活函数

每层中神经元的数据量是怎么决定的？

输入层：根据数据特征数量设置神经元。例如 28x28 的图像展平后有 784 个特征，所以输入层有784个神经元。
隐藏层：神经元数量一般通过经验和试验确定，前层神经元数量相对较多，用于学习更具体的局部特征，后层减少神经元数量，迫使模型抽象特征，降低模型复杂度，减少过拟合风险。
输出层 ：输出层神经元的数量由具体的任务和输出的类别数量决定
- 分类任务：在多分类问题中输出层神经元的数量等于类别的数量。例如手写数字识别任务，要识别的数字有 0 - 9 共 10 个类别，所以输出层就设置 10 个神经元
- 回归任务：输出层神经元的数量通常为 1 个。例如预测房价，只需要一个预测值，输出层就设置 1 个神经元。

激活函数

激活函数（Activation Function）是神经网络中每个神经元输出时应用的非线性变换函数。它决定了一个神经元是否被激活，以及传递给下一个神经元的信息量。若没有激活函数，多层神经网络将退化为线性模型，无法学习复杂的非线性关系。有几个常用的激活函数：

ReLU：输出范围在 [0, ∞) 之间，计算简单且高效，能够有效缓解梯度消失问题，是当前最常用的隐藏层激活函数。
Sigmoid：输出范围在 (0, 1) 之间，将输入映射为 0 到 1 之间的概率值，常用于二分类问题的输出层。
Softmax：每个元素在 (0, 1) 之间，且所有元素之和为 1，通常用于多分类任务的输出层，用于表示每个类别的概率。

训练模型

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

python 复制代码

model.compile(optimizer='adam',
              loss='sparse_categorical_crossentropy',
              metrics=['accuracy'])

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

接下来就可以按照指定的参数配置，使用训练集数据对模型进行迭代训练，同时使用验证数据评估模型的性能

python 复制代码

model.fit(
    train_images, train_labels, 
    epochs=5, batch_size=32,
    validation_data=(val_images, val_labels)
)

epochs：指定模型对整个训练数据集进行训练的轮数。单次训练难以让随机初始化参数的模型收敛到较优解，多轮训练可通过多次迭代更新参数、充分学习数据分布规律。
batch_size：指定每次训练处理的样本数，在训练过程中模型不会一次性处理整个训练数据集，而是将训练数据分成多个小批次（batch），每次只处理一个批次的数据，并根据该批次数据的梯度更新模型的参数。
validation_data：在训练过程中对模型进行验证。

在每一轮训练中，训练数据会被分成多个批次，模型依次处理每个批次的数据，并根据该批次数据的梯度更新模型的参数。每一轮训练结束后，模型会使用验证数据进行评估，并输出验证集上的损失和评估指标。重复上述过程，直到达到指定的训练轮数。

MNIST 训练集共有 60000 张图片，20% 的数据划分为验证集，训练集实际使用 48000 张图片，每批 32 张图片，每个 epoch 需要 1500 步才能处理完所有训练数据

随着训练轮数的增加，模型通常会逐渐学习到数据中的模式和特征，损失函数的值持续下降，模型的 accuracy 达到 98.8%。但并不是轮数越多越好，过多的训练轮数可能会导致过拟合，即模型在训练集上表现很好，但在测试集上表现不佳。

评估模型

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

python 复制代码

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

测试准确率 0.9749（约 97.5%）看来模型训练效果还不错

进行预测

有了模型之后就能对测试集做个预测，看看整体效果了

python 复制代码

# 进行预测
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]}")

感兴趣也可以把预测结果用图形表示

python 复制代码

import matplotlib.pyplot as plt

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

完整代码

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

这段代码使用了全连接神经网络（Fully Connected Neural Network）架构，也称为多层感知机（Multi-Layer Perceptron，MLP）

输入层：接收 28×28 像素的手写数字图像
Flatten 层：将 2D 图像 (28×28) 展平为一维向量 (784)
第一个隐藏层：128 个神经元，使用ReLU激活函数
第二个隐藏层：64 个神经元，使用 ReLU 激活函数
输出层：10 个神经元（对应 0-9 十个数字类别），使用 softmax 激活函数

这是一个基础神经网络模型，没有使用卷积层或其它复杂结构，只使用了全连接层。如果使用 CNN 模型架构，核心代码大概是这样

ini 复制代码

# 定义 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

Transformer 是基于自注意力机制的神经网络架构，主要用于自然语言处理（NLP）等序列建模任务，本质上是一种解决问题的设计理念与方案。
TensorFlow 是由 Google 开发的开源机器学习框架，提供了丰富的工具和库来构建、训练和部署各种机器学习模型，本质上是一个工具实现。

可以利用 TensorFlow 提供的操作、函数和类来实现 Transformer 架构，进行模型训练和推理。工程同学也能简单把 Transformer 和 Tensorflow 的关系理解为 MVC 架构与 Spring MVC 的关系。

Tensorflow 与 PyTorch

TensorFlow 与 PyTorch 是当前深度学习领域中最为流行的两个开源框架：

TensorFlow 由 Google Brain 团队于 2015 年 11 月发布，原生支持分布式计算，适合大规模模型和数据的训练。在 TensorFlow 1.x 时代，静态计算图的概念对于初学者来说较为复杂。2017 年发布 TensorFlow 2.0，强调易用性与灵活性，集成了 Keras 高级 API，支持动态图模式，提高了用户体验。
PyTorch 由 Facebook 于 2016 年 1 月发布，旨在为研究人员提供一个灵活且高效的深度学习框架。发布初版采用动态计算图，使得模型构建和调试过程更加直观和简便，尤其适合研究和快速原型开发。2018 年发布 PyTorch 1.0，标志着框架的成熟，增强了生产部署能力。

两者各有优势，TensorFlow 更加适合需要强大部署能力和完整生态系统的工业应用，而 PyTorch 则因其灵活性和易用性，深受研究人员和开发者的青睐，超过 80% 的新研究论文优先使用 PyTorch 实现，虽然文中示例主要是用 Tensorflow，但如果仅仅是想了解深度学习，建议使用 PyTorch。