Skip to main content

机器学习

  • 人工智能（Artificial Intelligence）属于计算机科学的分支，是让各类机器载体上模拟并拥有类似生物的智能，让机器可以进行感知、学习、识别、推理等行为的计算机科学技术。

  • 机器学习（Machine Learning,ML）是实现人工智能的核心方法，传统的机器学习主要关注如何学习一个预测模型，将数据表示为特征后将特征输入到预测模型，并输出预测结果。现代机器学习则主要由神经网络来完成。

  • 神经网络（Neural Network,NN）是机器学习的一个分支，主要关注如何使用神经网络来学习数据的表示，并使用这些表示来完成各种通用类型的任务。

  • 深度学习（Deep Learning,DL）是神经网络的一个分支，主要关注如何使用层数较多的且参数较多的神经网络来学习数据。

下面是一个只用加减乘除实现求某数平方根的示例：

# 我们要求解的数
target_number = 17.0

# 初始化权重（我们的猜测值）
weight = 1

# 超参数
learning_rate = 0.01  # 学习率
epochs = 1000        # 训练轮数

# 训练过程
for epoch in range(epochs):
    # 前向传播: 计算预测值 (weight * weight 应该等于 target_number)
    prediction = weight * weight
    
    # 计算损失: 均方误差 (MSE)
    loss = (prediction - target_number) ** 2

    # 反向传播: 计算损失（loss）对权重（weight）的梯度
    gradient = 2 * (prediction - target_number) * 2 * weight
    
    # 更新权重 (梯度下降)
    weight = weight - learning_rate * gradient

# 最终结果
print(f"\n训练后的平方根估计值: {weight}")
print(f"误差: {target_number - prediction}")

上述代码展示了机器学习的核心概念：

  1. 学习率：控制每次参数更新的步长
  2. 前向传播：使用当前权重进行预测
  3. 损失计算：衡量预测值与目标值之间的差距
  4. 反向传播：计算损失对权重的梯度
  5. 梯度下降：沿梯度方向更新权重，最小化损失函数

这个简单的例子虽然不是典型的神经网络，但展示了机器学习的基本原理：通过不断调整参数，使模型输出逐渐接近目标值。

不同的接近方法即为不同的算法，要注意，没有一个算法是万能的，需要根据具体问题选择合适的算法。“All models are wrong, but some are useful.”?

如果数据较大，则必须要对数据做各种预处理，数据的质量决定了模型的上限。这也是一个非常耗费时间且需要经验的工作。

现代深度学习往往需要大量的算力，如何高效的利用算力，也是一个方向，例如分布式训练、混合精度训练、模型剪枝、知识蒸馏、高效微调等。

机器学习步骤​

数据清洗​

数据决定着模型预测的上界，模型则是尽可能达到这个上界。

特征工程​

好的特征工程就像是衡量人的体重是否超标时，构造出BMI。这种数据直觉是AI较难替代的。

BMI=体重/(身高)2BMI = \text{体重} / (\text{身高})^2

模型参数调节​

至少从抽象层面上了解每个模型的工作原理，才能理解参数的含义。

模型融合​

实在没有办法提升性能，可以试试多模型融合，模型是可以互补的。

PyTorch​

在我们这个时代有许多优秀的机器学习框架，其中pytorch明显优于其他框架。

许多著名的深度学习模型和框架都是基于 PyTorch（Torch）二次开发的。例如：YOLOv11、Transformers (Hugging Face)、Stable Diffusion等。还有一些开源项目使用pytorch构建出可用的多模态大模型。上限非常高。

PyTorch 可以利用计算加速设备（例如GPU、NPU），为了达成这一目的，PyTorch 的安装会绑定对应的cuda版本，PyTorch 使用 cuda 的接口来操作底层硬件。

info

CUDA：NVIDIA 专为自家 GPU 设计的 C++ 并行计算框架，其运行依赖于 NVIDIA 显卡驱动程序。它允许开发者利用 GPU 强大的并行计算能力加速各类计算密集型任务。能把复杂的计算任务（比如矩阵乘法、神经网络运算）翻译成GPU能理解的指令。没有CUDA，GPU只能处理简单的图形渲染，无法参与深度学习的计算。

cuDNN：cuDNN 是专门为深度学习优化的“外挂包”，它基于 CUDA 开发，针对神经网络的关键操作（如卷积、池化层）做了极致优化，相当于给数学天才（GPU）配了一把趁手的“瑞士军刀”。如果用原始 CUDA 开发大模型，就像用菜刀切牛排——能切但效率低。cuDNN直接提供预制好的高效函数，比如把图像识别中的卷积运算速度提升2倍以上，还能减少内存占用，让大模型跑得更流畅。

CUDA Toolkit (NVIDIA 官方版)：完整的 CUDA 开发环境，包含：

  • NVIDIA 显卡驱动程序
  • NVCC：NVIDIA CUDA 编译器，是 CUDA Toolkit 的核心组件，负责将 CUDA 代码编译为可在 NVIDIA GPU 上执行的二进制代码。
  • 完整的 CUDA 开发工具链（编译器、IDE、调试器等）
  • 各种 CUDA 加速库及其头文件
  • 文档和示例代码

CUDA Toolkit (PyTorch 版)：精简版 CUDA 工具包，主要包含：

  • 运行 CUDA 功能所需的核心动态链接库
  • 不包含驱动程序、开发工具及完整文档
  • 专为支持 PyTorch 等框架的 CUDA 功能而设计

不过同样的测试代码，在WSL2中安装的cuda对显卡性能会存在一定的影响。

# windows原生环境
name: NVIDIA GeForce RTX 3090 Ti
write speed: 5063.91 MB/s
read speed: 5565.53 MB/s

# windows下的WSL2 Ubuntu-24.04 环境
name: NVIDIA GeForce RTX 3090 Ti
write speed: 2632.96 MB/s
read speed: 4429.29 MB/s

torch框架​

torchvision​

torchvision 是 PyTorch 项目的一部分。由流行的数据集、模型架构和计算机视觉的常见图像转换组成。

这些数据集包括了各种类型的数据，如图像、文本、音频等，可以用于各种任务，如分类、回归、聚类等。

安装：pip install torchvision

数据集名称加载方法模型类型数据大小(样本数*特征数)
MNISTtorchvision.datasets.MNIST分类70000*784
CIFAR-10torchvision.datasets.CIFAR10分类60000*3072
Fashion MNISTtorchvision.datasets.FashionMNIST分类70000*784
import torchvision.datasets as datasets
# 加载数据集
train_dataset = datasets.MNIST(root='./data', train=True, download=True)
test_dataset = datasets.MNIST(root='./data', train=False, download=True)

torchtext​

简化文本数据处理（分词/词嵌入/标记化）,内置 NLP 数据集（IMDB 影评等）

安装：pip install torchtext

  # 情感分析快速实现
  from torchtext.data import Field, TabularDataset
  
  TEXT = Field(tokenize='spacy')
  LABEL = Field(sequential=False)
  train_data = TabularDataset(path='train.csv', format='csv', 
                             fields=[('text', TEXT), ('label', LABEL)])

Ignite​

训练流程管理库，可以简化训练循环代码、内置进度条/早停/模型保存等实用功能、官方示例丰富

安装：pip install pytorch-ignite

from ignite.engine import Events, create_supervised_trainer

trainer = create_supervised_trainer(model, optimizer, loss_fn)

@trainer.on(Events.ITERATION_COMPLETED(every=100))
def log_loss(engine):
    print(f"Epoch {engine.state.epoch}, Loss: {engine.state.output:.2f}")

神经网络​

凡是模仿人的神经网络构建出来的数学模型，都叫神经网络，或者人工神经网络。

神经网络可以归为三块：

  • BP 神经网络（Backpropagation Neural Network）

神经网络非常多，今天你根据生物神经网络构建一个模型，明天我根据生物神经网络构建一个。1986 年，Romelhart 和 Mcclelland，提出了一个特殊的结构，使用了反向传播（Backpropagation）算法，并命名：BP 神经网络。

BP 神经网络提出后，瞬间崛起后当了主力军。在不特指时，往往说神经网络都是指 BP 神经网络。

  • 全连接神经网络（Fully Connected Neural Network）

全连接神经网络，是一种最基础、最经典的神经网络结构。它的特点是：网络中相邻两层的所有神经元之间都有连接。也就是说，前一层的每个神经元都与后一层的每个神经元相连。信息只从输入层流向隐藏层，再流向输出层，没有"跳过"中间层的连接。这种网络是最早被广泛研究和使用的神经网络类型，也是理解深度学习的基础。

由多个全连接层组成的前馈神经网络，也称为多层感知机（Multi-Layer Perceptron, MLP）。

  • 深度学习（Deep Learning）

BP 神经网络虽然很好用，但当要处理图象、音频、文字等问题时，却不行了，BP 神经网络的参数会随着输入个数指数增长。例如一个 50 * 50 像素的图象，就有 2500 个输入。假设有 100 个隐节点，则 2500 个输入在第一层的权重参数就有 2500 * 100 个，参数个数量级太爆炸，导致 BP 在求解时，很难找到优秀解就宕机了。这本来是个没办法的事，但偏偏图象、音频这些问题，它的输入存在很严重的相关性（例如相邻像素的值总是相近的）因此，可以根据这个业务特性，进行输入个数压缩，或者在求解时根据这个业务特性进行特殊讨巧（例如相邻输入对应的权重参数共享）使 BP 神经网络又可以解决这类问题了。问题解决了，BP 还是 BP，挂个名：深度学习！你可以把深度学习看作是 BP 神经网络的一种加强版，解决输入极极极极多的问题。

神经元与神经元之间是以神经冲动的模式进行传值，信号到了神经元，都是以电信号的形式存在，当电信号在神经元积累到超过阈值时，就会触发神经冲动，将电信号传给其它神经元。正是根据这个思路，就构造出了以上的神经网络结构。

tip

动画演示

一张 28*28 的图片可以抽象为一个 784 维的向量，每个像素点的值就是向量的一个分量。我们可以将这个向量作为输入，通过神经网络，输出一个 10 维的向量，每个分量代表图片属于某个数字的概率。

一个有 784 个输入节点，16 个隐藏节点，10 个输出节点的神经网络结构，用线性代数的方法简洁表示层与层之间的权重：

a01=σ(∑i=1784(w0,i⋅ai0)+b0)a11=σ(∑i=1784(w1,i⋅ai0)+b1)⋮a151=σ(∑i=1784(w15,i⋅ai0)+b15)\begin{aligned} a_{0}^{1} &= \sigma \left( \sum_{i=1}^{784} (w_{0,i} \cdot a_{i}^{0}) + b_{0} \right)\\ a_{1}^{1} &= \sigma \left( \sum_{i=1}^{784} (w_{1,i} \cdot a_{i}^{0}) + b_{1} \right)\\ &\vdots\\ a_{15}^{1} &= \sigma \left( \sum_{i=1}^{784} (w_{15,i} \cdot a_{i}^{0}) + b_{15} \right) \end{aligned}

矩阵表示

[w0,0w0,1...w0,784w1,0w1,1...w1,784............w15,0w15,1...w15,784]\begin{bmatrix} w_{0,0} & w_{0,1} & ... & w_{0,784} \\ w_{1,0} & w_{1,1} & ... & w_{1,784} \\ ... & ... & ... & ... \\ w_{15,0} & w_{15,1} & ... & w_{15,784} \end{bmatrix} 
import torch
import torch.nn as nn
import torch.optim as optim
import torchvision
import torchvision.transforms as transforms
from torch.utils.data import DataLoader

# 定义数据转换
# Compose 是一个函数，用于将多个变换组合在一起
transform = transforms.Compose([
    # 将图像转换为张量
    transforms.ToTensor(),
    # 将图像的像素值转换为0.1307附近，标准差为0.3081
    # 为什么是0.1307和0.3081？
    # 因为MNIST数据集的像素值是0-255，转换为0-1之间的值
    # 0.1307是MNIST数据集的均值，0.3081是MNIST数据集的标准差
    # 所以需要将图像的像素值转换为0.1307附近，标准差为0.3081
    transforms.Normalize((0.1307,), (0.3081,))  
])

# 加载MNIST数据集
# root：数据集的根目录
# train：是否为训练集(获取带有train=True的数据集)
# download：是否下载数据集，如果没有，则下载
# transform：数据转换
train_dataset = torchvision.datasets.MNIST(root='./data', train=True, download=True, transform=transform)
test_dataset = torchvision.datasets.MNIST(root='./data', train=False, download=True, transform=transform)

# 创建数据加载器
# batch_size：每个batch（批次）的大小
# 如果batch_size=1，则每次只取一个样本，则不需要打乱数据集
# 如果batch_size=1000，则每次取1000个样本，则需要打乱数据集
# 较大的batch_size可以提高训练速度，但可能会导致内存不足
# shuffle：是否打乱数据集
batch_size = 32
train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True)
test_loader = DataLoader(test_dataset, batch_size=batch_size, shuffle=False)

# 定义神经网络模型
# 继承自nn.Module，所以需要实现forward方法
class NeuralNetwork(nn.Module):
    def __init__(self, input_size, hidden_size, output_size):
        # 调用父类nn.Module的构造函数
        super(NeuralNetwork, self).__init__()
        # 初始化线性层1
        self.layer1 = nn.Linear(input_size, hidden_size)
        # 初始化ReLU激活函数
        self.relu = nn.ReLU()
        # 初始化线性层2
        self.layer2 = nn.Linear(hidden_size, output_size)

    # 在PyTorch中forward是一个特殊方法名，是模型正向传播的标准命名
    # 由于nn.Module继承自nn.Module，所以需要实现forward方法，forward方法中的数据会被记录，用于下方loss.backward()自动反向传播
    def forward(self, x):
        # 将图像展平
        x = x.reshape(-1, input_size)  
        # 执行线性层1的前向传播计算
        x = self.layer1(x)
        # 执行ReLU激活函数
        x = self.relu(x)
        # 执行线性层2的前向传播计算
        x = self.layer2(x)
        return x

    # # 反向传播
    # def backward(self, x):
    #     # 执行线性层1的反向传播计算
    #     x = self.layer1.backward(x)
    #     # 执行ReLU激活函数的反向传播计算
    #     x = self.relu.backward(x)
    #     # 执行线性层2的反向传播计算
    #     x = self.layer2.backward(x)

# 创建模型实例
# 输入层：28*28=784
input_size = 28 * 28 
# 隐藏层：128（可以设置为其他值，通常设为2的幂次方，且不超过输入层的一半）
hidden_size = 128
# 输出层：10  （因为MNIST数据集有10个类别）
output_size = 10
model = NeuralNetwork(input_size, hidden_size, output_size)

# 定义损失函数和优化器
# 重点1：损失函数
# 常见的损失函数有：交叉熵、均方误差
# 交叉熵损失函数：用于分类问题，计算预测值和真实值之间的差异
# 公式：loss = -sum(y_true * log(y_pred))
# 均方误差：用于回归问题，计算预测值和真实值之间的差异
# 公式：loss = sum((y_true - y_pred) ** 2)
criterion = nn.CrossEntropyLoss()
# 重点2：优化器
# 常见的优化器有：随机梯度下降、Adam、RMSprop等
# SGD：随机梯度下降
# 公式：optimizer = optim.SGD(model.parameters(), lr=0.01)
# lr：学习率，用于控制每次更新参数的步长
# momentum：动量，用于加速梯度下降
# 梯度计算公式与momentum有关，最终更新的梯度为：g_v = momentum * g_v + lr * grad
# 其中grad是梯度，lr是学习率，momentum是动量，g_v是最终更新的梯度
optimizer = optim.SGD(model.parameters(), lr=0.01, momentum=0.9)
# 训练模型，epochs是训练的轮数，训练的轮数越多，训练的越充分，但训练时间越长
# 训练的前期梯度下降较多，后期梯度下降较少，因为后期梯度较小，所以需要较小的学习率
epochs = 5

for epoch in range(epochs):
    running_loss = 0.0
    for i, (images, labels) in enumerate(train_loader):
        # 模型训练,把模型设置为训练模式
        # 激活BatchNorm层的参数更新机制，使用当前批次的均值和方差进行归一化，并更新运行时统计值
        # 激活Dropout层，随机丢弃一部分神经元，防止过拟合
        # 确保梯度计算和参数更新正常进行
        model.train()
        # 前向传播
        outputs = model(images)
        # 计算损失
        loss = criterion(outputs, labels)
        # 梯度清零，如果不清零，梯度会累加
        optimizer.zero_grad()
        # 反向传播
        '''
PyTorch的自动微分引擎很智能（你也可以在模型中像构建前向传播一样，手动设置backward方法），它能够自动处理梯度在计算图中的流动。
不需要我们明确指定梯度应该传播到哪个模型。
只要模型的参数参与了损失的计算，它们就会自动成为梯度计算的一部分。
1. 当你执行前向计算时，PyTorch会在后台构建一个动态计算图，记录所有操作及其依赖关系。每个张量都会存储信息，指向创建它的操作（存储在`grad_fn`属性中）。
2. 损失函数（如`loss`）是这个计算图的一个节点，通过`.backward()`方法，PyTorch会从这个节点开始沿着计算图向后追踪所有需要计算梯度的参数。
3. 当创建模型时，所有参数都会自动设置`requires_grad=True`，这些参数会被纳入计算图中。当计算损失时，这些参数通过一系列操作与损失函数相连接。
4. PyTorch会自动追踪从损失到各个参数的路径，不需要明确指定模型。这是因为计算图包含了所有操作的完整记录，包括哪些参数参与了计算。
        '''
        loss.backward()
        # 更新参数,更新参数的公式为：weight = weight - lr * grad
        optimizer.step()
        # 累计损失
        running_loss += loss.item()
        
    # 每个epoch结束后计算准确率
    correct = 0
    total = 0
    # 测试模型
    # 测试模型时，不需要计算梯度，即关闭后台自动的梯度计算
    with torch.no_grad():
        # 加载测试集
        for images, labels in test_loader:
            # 测试模型，把模型设置为测试模式
            # BatchNorm层会使用运行时统计数据而不是批次统计数据
            # Dropout层会停止随机丢弃神经元
            model.eval()
            outputs = model(images)
            # 获取预测值
            # 区别与torch.maximum
            # torch.max会返回两个值，一个是最大值，一个是最大值的索引
            # 而torch.maximum只会返回最大值
            # 点击进入这个方法，可以看到示例
            _, predicted = torch.max(outputs.data, 1)
            # 累计样本数,labels.size(0) 表示当前批次中样本的数量。
            # 在测试过程中，当使用 DataLoader 加载数据时，每个批次可能包含多个样本（由 batch_size 决定）。
            total += labels.size(0)
            # 累计正确样本数
            # 计算预测值与真实值相等的样本数
            print(predicted) # 得到长度为batch_size的向量（预测值）
            print(labels) # 得到长度为batch_size的向量(真实值)
            
            # 计算预测值与真实值相等的样本数
            test = (predicted == labels)
            # [ True .... False ],Python计算布尔值的时候，把True当作1，False当作0
            # 所以test.sum()就是预测值与真实值相等的样本数
            # .item() 方法用于将张量转换为标量（即一个数值）用于加法计算
            correct += test.sum().item()
    
    accuracy = correct / total
    print(f'Epoch {epoch+1}/{epochs}, Loss: {running_loss/len(train_loader):.4f}, Accuracy: {accuracy:.4f}')

# 评估模型
correct = 0
total = 0
# 关闭梯度计算
with torch.no_grad():
    for images, labels in test_loader:
        # 测试模型，把模型设置为测试模式
        """
本代码不加model.train()和model.eval()原因有以下几点：
1. 模型中没有BatchNorm和Dropout等层，调用与否确实不会有区别
2. 创建模型后，PyTorch默认是训练模式，所以不调用model.train()也能正常训练，只有明确调用model.eval()后才会切换到评估模式

更复杂的模型如ResNet、BERT等都包含这些层。
所以需要养成习惯始终在相应阶段调用model.train()和model.eval()
这样代码更规范，也能避免在模型变复杂后出现意外问题。
        """
        model.eval()
        outputs = model(images)
        _, predicted = torch.max(outputs.data, 1)
        total += labels.size(0)
        correct += (predicted == labels).sum().item()

accuracy = correct / total
print(f'测试集准确率: {accuracy:.4f}')

图像识别​

在现实生活中并不存在一个场景，给你单独一个数字让你进行识别。但是有一些类似的场景，譬如：车牌号、发票号码、网站的验证码等。针对这些场景，我提供一些思路：

  • 我们需要对图像进行分割，下面是一个分割 4 个字的验证码的例子
  • 分割完成后再将结果依次做标准化处理，譬如压缩数组大小
  • 逐一识别，返回结果

下面代码以numpy版本的神经网络为例：

from PIL import ImageFont,Image,ImageDraw
# 生成一个验证码
c_chars = "0 1 2 3 4"
path = 'test.png'
size = (100,24)                             #图片大小
img = Image.new("RGB",size)
draw = ImageDraw.Draw(img)                  #draw一个
font = ImageFont.truetype("arial.ttf", 23)      #字体
draw.text((5,0),c_chars,font=font,fill="white") #字颜色
# img.show()
img.save(path)

# 分割图片
def sliceImg(img_path, count = 5):
    img = Image.open(img_path).convert("L")
    w, h = img.size
    eachWidth = int(w/count)
    for i in range(count):
        box = (i * eachWidth, 0, (i + 1) * eachWidth, h)
        yield img.crop(box)

# 转化图片
def exchange(img):
    target_size = (8, 8)
    resized_image = img.resize(target_size)
    # resized_image.show()
    return resized_image


out = ""
for i in sliceImg(path):
    # .flatten()方法将数组转化为列表
    original_array =  numpy.array(exchange(i)).flatten()
    # 将数据0-1化
    inputs = (original_array / 255.0 * 0.99) + 0.01
    # 查询网络
    outputs = n.query(inputs)
    # print(outputs)
    # 最高值的索引对应于标签
    label = numpy.argmax(outputs)
    out+=str(label)
print(out)

从结果上我们可以看到，0、1、2、4 被正确的识别了。但数字 3 没有被正确的识别。请思考这个案例中，最有效的优化方式。

答案A：优化图片裁切结构，使用其他膨胀、侵蚀、over padding等算法

答案B：增加回声，强化模型能力

答案C：增加训练次数

答案D：其他

# 这里我检查了转化后8*8的数字3的图片，对比了手写数字3和手写数字8，
# 我认为生成的数字3与手写8更接近相对于与手写3
# 所以我认为的解决的方案是：给模型再喂一些生成数字3的样本。

from PIL import ImageFont,Image,ImageDraw
# 生成一个验证码
c_chars = "3 3 3 3 3"
path = 'test.png'
size = (100,24)                             #图片大小
img = Image.new("RGB",size)
draw = ImageDraw.Draw(img)                  #draw一个
font = ImageFont.truetype("arial.ttf", 23)      #字体
draw.text((5,0),c_chars,font=font,fill="white") #字颜色
# img.show()
img.save(path)

# 分割图片
def sliceImg(img_path, count = 5):
    img = Image.open(img_path).convert("L")
    w, h = img.size
    eachWidth = int(w/count)
    for i in range(count):
        box = (i * eachWidth, 0, (i + 1) * eachWidth, h)
        yield img.crop(box)

# 转化图片
def exchange(img):
    target_size = (8, 8)
    resized_image = img.resize(target_size)
    # resized_image.show()
    return resized_image


for i in sliceImg(path):
    # .flatten()方法将数组转化为列表
    original_array =  numpy.array(exchange(i)).flatten()
    # 将数据0-1化
    inputs = (original_array / 255.0 * 0.99) + 0.01
    targets = numpy.zeros(output_nodes) + 0.01
    # all_values[0] 是此记录的目标标签
    targets[int(3)] = 0.99
    n.train(inputs, targets)

# 生成一个验证码
c_chars = "0 1 2 3 4"
path = 'test.png'
size = (100,24)                             #图片大小
img = Image.new("RGB",size)
draw = ImageDraw.Draw(img)                  #draw一个
font = ImageFont.truetype("arial.ttf", 23)      #字体
draw.text((5,0),c_chars,font=font,fill="white") #字颜色
# img.show()
img.save(path)

out = ""
for i in sliceImg(path):
    # .flatten()方法将数组转化为列表
    original_array =  numpy.array(exchange(i)).flatten()
    # 将数据0-1化
    inputs = (original_array / 255.0 * 0.99) + 0.01
    # 查询网络
    outputs = n.query(inputs)
    # print(outputs)
    # 最高值的索引对应于标签
    label = numpy.argmax(outputs)
    out+=str(label)
print(out)

# 移除生成的图片，保持文件夹的整洁
import os
os.remove(path)

可以看到输出的结果已经正确的显示为1、2、3、4。如此一来。模型就算训练完成了。

LeNet-5​

LeNet-5被认为是卷积神经网络（CNN）的开山之作，主要用于手写数字识别。它包含了卷积层、池化层和全连接层，是现代CNN的雏形。

卷积​

卷积神经网络(convolutional neural network)简称CNN。卷积神经网络的核心是卷积核，卷积核在图像处理领域可以用来提取图像的纵向和横向特征。

卷积核的大小一般为奇数，如3x3，5x5，7x7等，卷积核通常与图像处理（over padding）后的图像进行卷积操作，卷积核在图像上滑动，每次滑动一个像素，对应位置的像素值与卷积核对应位置的值相乘，然后求和，最后将求和的结果作为卷积核中心像素的值，这样就得到了一个新的图像。

新的图像可以用更少的数据反应出图像的特征。这个过程就是特征提取。

我们从一个6x6的矩阵开始：

A=[a11a12a13a14a15a16a21a22a23a24a25a26a31a32a33a34a35a36a41a42a43a44a45a46a51a52a53a54a55a56a61a62a63a64a65a66]\mathbf{A} = \begin{bmatrix} a_{11} & a_{12} & a_{13} & a_{14} & a_{15} & a_{16} \\ a_{21} & a_{22} & a_{23} & a_{24} & a_{25} & a_{26} \\ a_{31} & a_{32} & a_{33} & a_{34} & a_{35} & a_{36} \\ a_{41} & a_{42} & a_{43} & a_{44} & a_{45} & a_{46} \\ a_{51} & a_{52} & a_{53} & a_{54} & a_{55} & a_{56} \\ a_{61} & a_{62} & a_{63} & a_{64} & a_{65} & a_{66} \\ \end{bmatrix}

我们的卷积核是一个3x3的矩阵：

K=[k11k12k13k21k22k23k31k32k33]\mathbf{K} = \begin{bmatrix} k_{11} & k_{12} & k_{13} \\ k_{21} & k_{22} & k_{23} \\ k_{31} & k_{32} & k_{33} \\ \end{bmatrix}

我们假设卷积核位于原始矩阵的左上角，覆盖的区域如下：

[a11a12a13a21a22a23a31a32a33]\begin{bmatrix} a_{11} & a_{12} & a_{13} \\ a_{21} & a_{22} & a_{23} \\ a_{31} & a_{32} & a_{33} \\ \end{bmatrix}

此时，输出矩阵的第一个元素O11O_{11}的计算为：

O11=k11⋅a11+k12⋅a12+k13⋅a13+k21⋅a21+k22⋅a22+k23⋅a23+k31⋅a31+k32⋅a32+k33⋅a33\begin{aligned} O_{11} &= k_{11} \cdot a_{11} + k_{12} \cdot a_{12} + k_{13} \cdot a_{13} \\ &\quad + k_{21} \cdot a_{21} + k_{22} \cdot a_{22} + k_{23} \cdot a_{23} \\ &\quad + k_{31} \cdot a_{31} + k_{32} \cdot a_{32} + k_{33} \cdot a_{33} \end{aligned}

整个输出矩阵

卷积核在整个6x6矩阵上滑动(从左至右，从上至下)，生成一个4x4的输出矩阵。输出矩阵的每个元素都按照上述方式计算。

点击查看卷积核动画
Live Editor
// 你可以尝试更改矩阵尺寸与卷积核的尺寸来感受卷积过程
function example(props) {
  // 使用 XPath 查询选择输出框
  const xpathSelector =
    "/html/body/div/div[2]/div/div/main/div/div/div/div/article/div[2]/div[1]/div[4]";
  const myElement = document.evaluate(
    xpathSelector,
    document,
    null,
    XPathResult.FIRST_ORDERED_NODE_TYPE,
    null
  ).singleNodeValue;
  // 矩阵尺寸
  const matrixSize = 6;
  // 卷积核尺寸
  const kernelSize = 3;
  const matrix = Array.from({ length: matrixSize }, (_, i) =>
    Array.from({ length: matrixSize }, (_, j) => `a${i + 1}${j + 1}`)
  );
  const [position, setPosition] = useState([0, 0]);
  useEffect(() => {
    const positions = [];
    for (let i = 0; i <= matrixSize - kernelSize; i++) {
      for (let j = 0; j <= matrixSize - kernelSize; j++) {
        positions.push([i, j]);
      }
    }

    let index = 0;
    const interval = setInterval(() => {
      setPosition(positions[index]);
      index = (index + 1) % positions.length;
    }, 1000);

    return () => clearInterval(interval);
  }, []);

  return (
    <div style={{ display: 'flex', justifyContent: 'center', alignItems: 'center', height: '100vh', backgroundColor: '#f0f0f0' }}>
      <div style={{ display: 'grid', gridTemplateColumns: `repeat(${matrixSize}, 50px)`, gridGap: '5px', position: 'relative' }}>
        {matrix.map((row, i) =>
          row.map((cell, j) => (
            <div
              key={`${i}-${j}`}
              style={{
                width: '50px',
                height: '50px',
                backgroundColor: '#fff',
                border: '1px solid #ccc',
                display: 'flex',
                justifyContent: 'center',
                alignItems: 'center',
                fontSize: '18px',
                backgroundColor: i >= position[0] && i < position[0] + kernelSize && j >= position[1] && j < position[1] + kernelSize ? 'yellow' : '#fff'
              }}
            >
              {cell}
            </div>
          ))
        )}
      </div>
    </div>
  );
}
Result
Loading...

最终输出矩阵O\mathbf{O}为：

O=[O11O12O13O14O21O22O23O24O31O32O33O34O41O42O43O44]\mathbf{O} = \begin{bmatrix} O_{11} & O_{12} & O_{13} & O_{14} \\ O_{21} & O_{22} & O_{23} & O_{24} \\ O_{31} & O_{32} & O_{33} & O_{34} \\ O_{41} & O_{42} & O_{43} & O_{44} \\ \end{bmatrix}

每个OijO_{ij}的具体计算方法如前所述，通过卷积核在原始矩阵上的滑动和计算得到。

通过这个例子，可以清晰地看到卷积核是如何对矩阵进行操作并生成输出的。

常见卷积核​

  1. 水平边缘检测：
[−1−1−1000111] \begin{bmatrix} -1 & -1 & -1 \\ 0 & 0 & 0 \\ 1 & 1 & 1 \end{bmatrix}

用途：检测水平边缘。

  1. 垂直边缘检测：
[−101−101−101] \begin{bmatrix} -1 & 0 & 1 \\ -1 & 0 & 1 \\ -1 & 0 & 1 \end{bmatrix}

用途：检测垂直边缘。

  1. Sobel算子（水平）：
[−101−202−101] \begin{bmatrix} -1 & 0 & 1 \\ -2 & 0 & 2 \\ -1 & 0 & 1 \end{bmatrix}

用途：检测水平边缘和梯度。

  1. Sobel算子（垂直）：
[121000−1−2−1] \begin{bmatrix} 1 & 2 & 1 \\ 0 & 0 & 0 \\ -1 & -2 & -1 \end{bmatrix}

用途：检测垂直边缘和梯度。

  1. 拉普拉斯算子：
[0101−41010] \begin{bmatrix} 0 & 1 & 0 \\ 1 & -4 & 1 \\ 0 & 1 & 0 \end{bmatrix}

用途：检测图像的二阶导数，强调边缘。

  1. 锐化：
[0−10−15−10−10] \begin{bmatrix} 0 & -1 & 0 \\ -1 & 5 & -1 \\ 0 & -1 & 0 \end{bmatrix}

用途：提高图像的清晰度。

  1. 高斯模糊（3x3）：
116[121242121] \frac{1}{16} \begin{bmatrix} 1 & 2 & 1 \\ 2 & 4 & 2 \\ 1 & 2 & 1 \end{bmatrix}

用途：平滑图像，减少噪声。

  1. 高斯模糊（5x5）：
1256[1464141624164624362464162416414641] \frac{1}{256} \begin{bmatrix} 1 & 4 & 6 & 4 & 1 \\ 4 & 16 & 24 & 16 & 4 \\ 6 & 24 & 36 & 24 & 6 \\ 4 & 16 & 24 & 16 & 4 \\ 1 & 4 & 6 & 4 & 1 \end{bmatrix}

用途：更强的平滑效果。

  1. 边缘增强：
[−1−1−1−19−1−1−1−1] \begin{bmatrix} -1 & -1 & -1 \\ -1 & 9 & -1 \\ -1 & -1 & -1 \end{bmatrix}

用途：增强边缘，使图像轮廓更加明显。

  1. 均值滤波：
19[111111111] \frac{1}{9} \begin{bmatrix} 1 & 1 & 1 \\ 1 & 1 & 1 \\ 1 & 1 & 1 \end{bmatrix}

用途：均匀地平滑图像。

import numpy as np
import matplotlib.pyplot as plt
from matplotlib.font_manager import FontProperties
import cv2

# 设置中文字体
# 替换为你系统中支持中文的字体路径(windows)
font_path = r'C:\Windows\Fonts\simhei.ttf'  
# mac（如果有的话）
# font_path = '/System/Library/Fonts/STHeiti Light.ttc' 
font_prop = FontProperties(fname=font_path)

# 读取灰度图像
image = np.array(cv2.imread('data/people.bmp',cv2.IMREAD_GRAYSCALE))

# 定义卷积核
kernels = {
    '水平边缘': np.array([[-1, -1, -1], [0, 0, 0], [1, 1, 1]]),
    '垂直边缘': np.array([[-1, 0, 1], [-1, 0, 1], [-1, 0, 1]]),
    'Sobel水平': np.array([[-1, 0, 1], [-2, 0, 2], [-1, 0, 1]]),
    'Sobel垂直': np.array([[1, 2, 1], [0, 0, 0], [-1, -2, -1]]),
    '拉普拉斯': np.array([[0, 1, 0], [1, -4, 1], [0, 1, 0]]),
    '锐化': np.array([[0, -1, 0], [-1, 5, -1], [0, -1, 0]]),
    '高斯模糊3x3': np.array([[1, 2, 1], [2, 4, 2], [1, 2, 1]]) / 16,
    '高斯模糊5x5': np.array([[1, 4, 6, 4, 1], [4, 16, 24, 16, 4], [6, 24, 36, 24, 6], [4, 16, 24, 16, 4], [1, 4, 6, 4, 1]]) / 256,
    '边缘增强': np.array([[-1, -1, -1], [-1, 9, -1], [-1, -1, -1]]),
    '均值滤波': np.array([[1, 1, 1], [1, 1, 1], [1, 1, 1]]) / 9
}

# 使用NumPy实现卷积操作
def convolve2d(image, kernel):
    # 获取图像和卷积核的尺寸
    i_height, i_width = image.shape
    k_height, k_width = kernel.shape
    
    # 计算输出图像的尺寸
    o_height = i_height - k_height + 1
    o_width = i_width - k_width + 1
    
    # 创建输出图像
    output = np.zeros((o_height, o_width))
    
    # 执行卷积操作
    for y in range(o_height):
        for x in range(o_width):
            # 提取图像区域
            region = image[y:y+k_height, x:x+k_width]
            # 计算卷积值
            output[y, x] = np.sum(region * kernel)
    
    return output

# 应用卷积核
results = {}
for name, kernel in kernels.items():
    # 为了处理边界，先对图像进行填充
    if kernel.shape[0] == 5:  # 对于5x5卷积核
        pad_width = 2
    else:  # 对于3x3卷积核
        pad_width = 1
    
    padded_image = np.pad(image, pad_width, mode='constant')
    filtered_image = convolve2d(padded_image, kernel)
    
    # 归一化处理，确保像素值在有效范围内
    filtered_image = np.clip(filtered_image, 0, 255).astype(np.uint8)
    results[name] = filtered_image

# 显示结果
plt.figure(figsize=(15, 8))
for i, (name, result) in enumerate(results.items()):
    plt.subplot(3, 4, i + 1)
    plt.imshow(result, cmap='gray')
    plt.title(name, fontproperties=font_prop)
    plt.axis('off')

plt.tight_layout()
plt.show()

池化​

池化（Pooling）是一种用于减少卷积神经网络（CNN）中特征图大小的操作。它通过将特征图上的局部区域进行聚合，得到一个更小的特征图。

池化操作类似卷积操作，使用的也是一个很小的矩阵，叫做池化核，但是池化核本身没有参数，只是通过对输入特征矩阵本身进行运算，它的大小通常是2x2、3x3、4x4等，然后将池化核在卷积得到的输出特征图中进行池化操作，需要注意的是，池化的过程中也有Padding方式以及步长的概念，与卷积不同的是，池化的步长往往等于池化核的大小。 最常见的池化操作为最大值池化（Max Pooling）和平均值池化（Average Pooling）两种。

import numpy as np

def pooling(input_array, pool_size=(2, 2), stride=None, mode='max'):
    """
    池化操作函数
    
    参数:
        input_array: 输入数组，形状为[height, width]或[batch, height, width, channels]
        pool_size: 池化窗口大小，默认为(2, 2)
        stride: 步长，默认与pool_size相同
        mode: 池化类型，'max'表示最大池化，'avg'表示平均池化
        
    返回:
        池化后的数组
    """
    # 如果未指定stride，则默认与pool_size相同
    if stride is None:
        stride = pool_size
    
    # 确保输入是numpy数组
    input_array = np.asarray(input_array)
    
    # 处理不同维度的输入
    if input_array.ndim == 2:  # 单通道2D输入
        h, w = input_array.shape
        d = 1
        input_array = input_array.reshape(1, h, w, 1)
    elif input_array.ndim == 3:  # 带批次或通道的3D输入
        raise ValueError("输入数组维度应为2D或4D")
    elif input_array.ndim == 4:  # 标准4D输入 [batch, height, width, channels]
        pass
    else:
        raise ValueError("输入数组维度应为2D或4D")
    
    # 获取输入尺寸
    batch_size, height, width, channels = input_array.shape
    
    # 计算输出尺寸
    out_height = (height - pool_size[0]) // stride[0] + 1
    out_width = (width - pool_size[1]) // stride[1] + 1
    
    # 初始化输出数组
    output = np.zeros((batch_size, out_height, out_width, channels))
    
    # 执行池化操作
    for b in range(batch_size):
        for c in range(channels):
            for i in range(out_height):
                for j in range(out_width):
                    h_start = i * stride[0]
                    h_end = h_start + pool_size[0]
                    w_start = j * stride[1]
                    w_end = w_start + pool_size[1]
                    
                    pool_region = input_array[b, h_start:h_end, w_start:w_end, c]
                    
                    if mode == 'max':
                        output[b, i, j, c] = np.max(pool_region)
                    elif mode == 'avg':
                        output[b, i, j, c] = np.mean(pool_region)
                    else:
                        raise ValueError("支持的模式为'max'或'avg'")
    
    # 如果输入是2D，则返回2D输出
    if input_array.shape[0] == 1 and input_array.shape[3] == 1:
        return output[0, :, :, 0]
    
    return output

# 示例使用
if __name__ == "__main__":
    # 创建测试数据
    test_data = np.array([
        [1, 2, 3, 4],
        [5, 6, 7, 8],
        [9, 10, 11, 12],
        [13, 14, 15, 16]
    ])
    
    # 最大池化
    max_pooled = pooling(test_data, pool_size=(2, 2), mode='max')
    print("最大池化结果:")
    print(max_pooled)
    
    # 平均池化
    avg_pooled = pooling(test_data, pool_size=(2, 2), mode='avg')
    print("平均池化结果:")
    print(avg_pooled)
'''
最大池化结果:
[[ 6.  8.]
 [14. 16.]]
平均池化结果:
[[ 3.5  5.5]
 [11.5 13.5]]
'''
  • over padding(填充)

有时图像的特征在边缘上，例如

import numpy as np
import matplotlib.pyplot as plt

# 读取图像
inputs = np.array([
  [255,1,2],
  [255,1,2],
  [255,1,2],]

)
# 用于提取纵向特征的卷积核
kernel = np.array([
  [0,1,0],
  [0,1,0],
  [0,1,0]]
)

# 卷积操作结果，没能正确获取边缘的特征
'''
[[0.   2.   0.]
 [0.   2.   0.]
 [0.   2.   0.]]
'''


# 对输入图像进行填充
# array: 需要填充的数组
# pad_width: 填充的宽度(上下左右都填充)
# mode: 填充的方式，通常为'constant',
# 有0、空、最大、平均、中位等11种参数可以选，点击方法进入查看
# constant_values: 填充的值，通常为0
inputs = np.pad(
    array=inputs,
    pad_width=1,
    mode='constant',
    constant_values=0
)


# 卷积操作
out_put = np.zeros((inputs.shape[0] - kernel.shape[0] + 1, inputs.shape[1] - kernel.shape[1] + 1))
out_put_w = out_put.shape[0]
out_put_h = out_put.shape[1]

for i in range(out_put_w):
    for j in range(out_put_h):
        conv_result = np.sum(inputs[i:i+kernel.shape[0], j:j+kernel.shape[1]] * kernel)
        out_put[i][j] = conv_result

# 卷积操作结果,正确的获取到了边缘的特征
print(out_put)
'''
[[510.   2.   4.]
 [765.   3.   6.]
 [510.   2.   4.]]
'''

步幅​

步幅表示卷积核移动的步长，步幅越大，卷积核每次跳跃的距离就越多，卷积核的感受野越小。

tip

感受野（Receptive Field）的定义：源自生物专业术语，在机器学习中表示卷积神经网络每一层输出的特征图（feature map）上的像素点映射回输入图像上的区域大小。通俗点的解释是，特征图上一点，相对于原图的大小，也是卷积神经网络特征所能看到输入图像的区域。

import numpy as np

def convolution_2d(input_array, kernel, stride=3):
    """
    实现2D卷积操作
    
    参数:
        input_array: 输入数组，形状为 (height, width)
        kernel: 卷积核，形状为 (kernel_size, kernel_size)
        stride: 卷积步长，默认为3
        
    返回:
        卷积结果数组
    """
    # 获取输入数组和卷积核的尺寸
    input_height, input_width = input_array.shape
    kernel_size = kernel.shape[0]
    
    # 计算输出数组的尺寸
    output_height = (input_height - kernel_size) // stride + 1
    output_width = (input_width - kernel_size) // stride + 1
    
    # 初始化输出数组
    output = np.zeros((output_height, output_width))
    
    # 执行卷积操作
    for i in range(output_height):
        for j in range(output_width):
            # 计算当前窗口的位置
            start_i = i * stride
            start_j = j * stride
            
            # 提取当前窗口
            window = input_array[start_i:start_i+kernel_size, start_j:start_j+kernel_size]
            
            # 计算卷积和
            output[i, j] = np.sum(window * kernel)
    
    return output

# 示例使用
if __name__ == "__main__":
    # 创建10x10的示例输入数组
    input_array = np.ones((8, 8))
    # 即输入数组每行列数据下标为 0-7 0-7
    
    # 创建5x5的卷积核
    kernel = np.ones((5, 5))
    
    # 执行卷积操作，步幅为3
    # 第一次卷积的区域为 0-4 0-4
    # 第二次卷积的区域为 3-7 3-7
    result = convolution_2d(input_array, kernel, stride=3)
    
    print("输入数组形状:", input_array.shape)
    print("卷积核形状:", kernel.shape)
    print("卷积结果形状:", result.shape)
    print("\n输入数组:")
    print(input_array)
    print("\n卷积核:")
    print(kernel)
    print("\n卷积结果:")
    print(result)
'''
输入数组形状: (10, 10)
卷积核形状: (5, 5)
卷积结果形状: (2, 2)

输入数组:
[[1. 1. 1. 1. 1. 1. 1. 1.]
 [1. 1. 1. 1. 1. 1. 1. 1.]
 [1. 1. 1. 1. 1. 1. 1. 1.]
 [1. 1. 1. 1. 1. 1. 1. 1.]
 [1. 1. 1. 1. 1. 1. 1. 1.]
 [1. 1. 1. 1. 1. 1. 1. 1.]
 [1. 1. 1. 1. 1. 1. 1. 1.]
 [1. 1. 1. 1. 1. 1. 1. 1.]]

卷积核:
[[1. 1. 1. 1. 1.]
 [1. 1. 1. 1. 1.]
 [1. 1. 1. 1. 1.]
 [1. 1. 1. 1. 1.]
 [1. 1. 1. 1. 1.]]

卷积结果:
[[25. 25.]
 [25. 25.]]
'''

手写数字识别​

这是pytorch实现

import torch
import torch.nn as nn
import torch.optim as optim
from sklearn.datasets import load_digits
from sklearn.model_selection import train_test_split
import numpy as np

# 加载数据 & 预处理
digits = load_digits()
X = digits.images.astype(np.float32) / 16.0  # 归一化到0~1
y = digits.target
X = X[..., np.newaxis]  # 添加通道维度 (n,8,8,1)
num_classes = 10

# 划分训练/验证集
X_train, X_val, y_train, y_val = train_test_split(
    X, y, test_size=0.2, random_state=42, stratify=y
)

# 转换为PyTorch张量，并调整为NCHW格式
X_train = torch.tensor(X_train).permute(0, 3, 1, 2)  # NHWC -> NCHW
X_val = torch.tensor(X_val).permute(0, 3, 1, 2)
y_train = torch.tensor(y_train, dtype=torch.long)
y_val = torch.tensor(y_val, dtype=torch.long)


# 定义模型
class SimpleConvNet(nn.Module):
    def __init__(self):
        super(SimpleConvNet, self).__init__()
        self.conv = nn.Conv2d(1, 8, kernel_size=3, padding=1)  # 输入1通道，输出8通道
        self.relu = nn.ReLU()
        self.pool = nn.MaxPool2d(kernel_size=2)  # 2x2池化
        self.fc = nn.Linear(4 * 4 * 8, num_classes)  # 全连接层

    def forward(self, x):
        x = self.conv(x)  # 卷积层
        x = self.relu(x)  # ReLU激活
        x = self.pool(x)  # 最大池化
        x = x.reshape(x.shape[0], -1)
        x = self.fc(x)  # 全连接层
        return x


# 创建模型、损失函数和优化器
model = SimpleConvNet()
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(model.parameters(), lr=0.1)

# 训练参数
epochs = 10
batch_size = 64

# 训练循环
for epoch in range(epochs):
    # 创建数据加载器进行批处理
    indices = torch.randperm(len(X_train))

    model.train()  # 设置为训练模式
    total_loss = 0

    # 小批量训练
    for i in range(0, len(X_train), batch_size):
        # 获取批次数据
        batch_indices = indices[i : i + batch_size]
        x_batch = X_train[batch_indices]
        y_batch = y_train[batch_indices]

        # 前向传播
        outputs = model(x_batch)
        loss = criterion(outputs, y_batch)
        total_loss += loss.item()

        # 反向传播和优化
        optimizer.zero_grad()  # 清除之前的梯度
        loss.backward()  # 反向传播
        optimizer.step()  # 更新参数

    # 验证
    model.eval()  # 设置为评估模式
    with torch.no_grad():  # 不计算梯度
        outputs = model(X_val)
        _, predicted = torch.max(outputs, 1)  # 获取最大值所在位置
        accuracy = (predicted == y_val).float().mean()

    print(
        f"Epoch {epoch+1}/{epochs}  loss={total_loss/len(indices)*batch_size:.4f}  val_acc={accuracy:.4f}"
    )
'''
Epoch 1/10  loss=2.2956  val_acc=0.4472
Epoch 2/10  loss=2.0604  val_acc=0.6167
Epoch 3/10  loss=1.5787  val_acc=0.7861
Epoch 4/10  loss=1.0126  val_acc=0.8000
Epoch 5/10  loss=0.6914  val_acc=0.7972
Epoch 6/10  loss=0.5458  val_acc=0.7917
Epoch 7/10  loss=0.4080  val_acc=0.8417
Epoch 8/10  loss=0.3853  val_acc=0.8778
Epoch 9/10  loss=0.3235  val_acc=0.9111
Epoch 10/10  loss=0.2700  val_acc=0.9250
'''

AlexNet​

在2012年ImageNet图像识别挑战赛中取得了巨大突破，是深度学习在计算机视觉领域爆发的标志。它比LeNet-5更深、更宽，使用了ReLU激活函数、Dropout等技术。

证明了GPU可以大幅提升神经网络的训练速度,证明了深度学习在计算机视觉领域的有效性。

info

《ImageNet Classification with Deep Convolutional Neural Networks》截止2025年，谷歌学术总引用次数排名第3。

ReLU激活函数​

Dropout​

ResNet​

ResNet引入了“残差连接”（Residual Connection），解决了深度神经网络中梯度消失和网络退化的问题，使得可以训练非常深的网络（例如152层）。

是深度学习领域最重要的突破之一，使得训练超深网络成为可能，极大地提升了图像识别的准确率。

info

《Deep Residual Learning for Image Recognition》截止2025年，机器视觉标签下，谷歌学术总引用次数排名第1。

残差连接​

Adam​

提出了一种高效且自适应的随机优化算法，通过结合一阶矩（动量）和二阶矩（自适应学习率）的估计，为每个模型参数独立调整学习率。

大幅简化了深度学习模型的训练过程，减少了手动调整学习率的需要，并保证了在稀疏梯度（尤其是在 NLP 中）下的稳定收敛。

成为深度学习，特别是自然语言处理（NLP）和 Transformer 架构的默认优化器之一。

info

《Adam: A Method for Stochastic Optimization》截止2025年，谷歌学术总引用次数排名第6。

Batch Normalizations​

提出了一种规范化网络层输入的方法，解决了训练深度网络时“内部协变量偏移”（Internal Covariate Shift）的问题，即中间层输入的分布在训练过程中不断变化的现象。

使得研究人员能够使用更高的学习率和更深的（更复杂的）网络架构进行训练，同时极大地加速了模型的收敛速度。

有效充当正则化器，减少了对 Dropout 等其他正则化技术的依赖。

info

《Batch Normalization: Accelerating Deep Network Training by Reducing Internal Covariate Shift》截止2025年，谷歌学术总引用次数排名第8。

LSTM​

info

LSTM（长短期记忆网络）是深度学习中最重要的架构之一。1997 年由 Hochreiter 和 Schmidhuber 提出，专门设计用于解决传统 RNN 的梯度消失问题，能够学习长期依赖关系。

LSTM 的核心创新：

  • 门控机制：通过遗忘门、输入门、输出门控制信息流动
  • 细胞状态：信息高速公路，让梯度能够长距离传播
  • 长期记忆：有效捕获序列中的长期依赖关系

《Long Short-Term Memory》论文截止 2025 年，谷歌学术总引用次数排名第 5，是深度学习领域最具影响力的论文之一。

原始论文：Long Short-Term Memory (1997)

Vision Transformer​

在现代深度学习中，文本、图片、音频、视频都是序列。

Vision Transformer（ViT）首次成功将 Transformer 架构（原用于 NLP）应用于图像分类任务，挑战了 CNN 在计算机视觉领域的主导地位。

ViT的成功是深度学习领域方法论的一次重大转变，标志着“大一统”架构（即 Transformer）开始统治 NLP 和 CV 两个领域。

info

《An Image is Worth 16x16 Words: Transformers for Image Recognition at Scale》在 2020 年及之后发表的论文中，谷歌学术总引用次数排名第1。

推荐资源​

李沐动手学深度学习