卷积神经网络：LeNet模型

M-YM2025-07-24 20:06

一、LeNet简介

LeNet由Yann Lecun 提出，是一种经典的卷积神经网络，是现代卷积神经网络的起源之一，主要用于解决手写数字识别问题。LeNet又称LeNet-5,具有一个输入层，两个卷积层，两个池化层，3个全连接层（其中最后一个全连接层为输出层）。

各个结构作用：

卷积层：提取特征图的特征，浅层的卷积提取的是一些纹路、轮廓等浅层的空间特征，对于深层的卷积，可以提取出深层次的空间特征。

池化层： 1、降低维度 2、最大池化或者平均池化，在本网络结构中使用的是最大池化。

全连接层： 1、输出结果 2、位置：一般位于CNN网络的末端。 3、操作：需要将特征图reshape成一维向量，再送入全连接层中进行分类或者回归。

LeNet-5 ，其结构简洁且具有明确的层次划分，专为处理32×32 像素的单通道（灰度）图像设计，具体层结构如下：

  1. 输入层

    • 接收 32×32×1 的灰度图像（如手写数字图片）。

  2. C1：卷积层

    • 卷积核尺寸：5×5
    • 卷积核数量：6
    • 输出特征图尺寸：28×28×6（因无填充，32-5+1=28）
    • 作用：提取图像的低级特征（如边缘、拐角、纹理等）。

  3. S2：池化层（下采样层）

    • 采用平均池化，池化窗口 2×2，步长 2
    • 输出特征图尺寸：14×14×6（28÷2=14）
    • 作用：降低特征图尺寸，减少计算量，同时增强特征的平移不变性。

  4. C3：卷积层

    • 卷积核尺寸：5×5
    • 卷积核数量：16
    • 输出特征图尺寸：10×10×16（14-5+1=10）
    • 作用：结合 S2 层的特征，提取更复杂的中级特征（如数字的局部结构）。

  5. S4：池化层

    • 平均池化，窗口 2×2，步长 2
    • 输出特征图尺寸：5×5×16（10÷2=5）
    • 作用：进一步降维，保留关键特征。

  6. C5：卷积层（等效全连接层）

    • 卷积核尺寸：5×5
    • 卷积核数量：120
    • 输出特征图尺寸：1×1×120（5-5+1=1）
    • 作用：因输出为 1×1，等效于全连接层，整合 S4 层的特征，输出 120 维特征向量。

  7. F6：全连接层

    • 输入：120 维
    • 输出：84 维
    • 作用：对 C5 层的特征进行非线性变换，进一步抽象特征。

  8. 输出层

    • 采用径向基函数（RBF）作为激活函数（原始设计），输出 10 维向量（对应 0-9 共 10 个数字）。
    • 现代应用中常替换为 Softmax 激活函数，输出类别概率分布。

最简单的LeNet模型。

python 复制代码 
import torch
import torch.nn as nn
import torch.nn.functional as F


class LeNet(nn.Module):
    def __init__(self):
        super(LeNet, self).__init__()
        # 定义卷积层
        self.conv1 = nn.Conv2d(in_channels=1, out_channels=6, kernel_size=5, stride=1)
        self.conv2 = nn.Conv2d(in_channels=6, out_channels=16, kernel_size=5, stride=1)

        # 定义全连接层
        self.fc1 = nn.Linear(16 * 5 * 5, 120)
        self.fc2 = nn.Linear(120, 84)
        self.fc3 = nn.Linear(84, 10)

        # 定义激活函数
        self.relu = nn.ReLU()

    def forward(self, x):
        # 卷积层 + 池化层 + 激活函数
        x = self.relu(self.conv1(x))
        x = F.avg_pool2d(x, kernel_size=2, stride=2)
        x = self.relu(self.conv2(x))
        x = F.avg_pool2d(x, kernel_size=2, stride=2)

        # 展平特征图
        x = torch.flatten(x, 1)

        # 全连接层
        x = self.relu(self.fc1(x))
        x = self.relu(self.fc2(x))
        x = self.fc3(x)

        return x

# 创建模型实例
model = LeNet()

# 打印模型结构
print(model)

二、Mnist数据集

MNIST是一个手写数字集合，该数据集来自美国国家标准与技术研究所, National Institute of Standards and Technology (NIST). 训练集 (training set) 由来自 250 个不同人手写的数字构成, 其中 50% 是高中学生, 50% 来自人口普查局 (the Census Bureau) 的工作人员. 测试集(test set) 也是同样比例的手写数字数据。

MNIST数据集简介

  1. 该数据集包含60,000个用于训练的示例和10,000个用于测试的示例。

  2. 数据集包含了0-9共10类手写数字图片,每张图片都做了尺寸归一化，都是28x28大小的灰度图。

  3. MNIST数据集包含四个部分： 训练集图像：train-images-idx3-ubyte.gz（9.9MB，包含60000个样本） 训练集标签：train-labels-idx1-ubyte.gz（29KB，包含60000个标签） 测试集图像：t10k-images-idx3-ubyte.gz（1.6MB，包含10000个样本） 测试集标签：t10k-labels-idx1-ubyte.gz（5KB，包含10000个标签）

python 复制代码 
import torch
from torchvision import datasets, transforms
from torch.utils.data import DataLoader
import matplotlib.pyplot as plt
import numpy as np
import struct

# 图像预处理：将图像转换为 (784, 1) 的张量
transform = transforms.Compose([
    transforms.ToTensor(),               # 转为 [0,1] 范围的 Tensor
    transforms.Lambda(lambda x: x.view(-1, 1))  # 展平为 (784, 1)
])

# 加载 MNIST 训练集和测试集
train_dataset = datasets.MNIST(
    root='./dataset',
    train=True,
    transform=transform,
    download=True
)

test_dataset = datasets.MNIST(
    root='./dataset',
    train=False,
    transform=transform,
    download=True
)

# 使用 DataLoader 批量加载
train_loader = DataLoader(
    dataset=train_dataset,
    batch_size=64,
    shuffle=True
)

test_loader = DataLoader(
    dataset=test_dataset,
    batch_size=64,
    shuffle=False
)

# ✅ 打印训练集和测试集的样本数量
print(f"训练集样本数量: {len(train_dataset)}")
print(f"测试集样本数量: {len(test_dataset)}")

# ✅ 控制台输出矩阵的代码
print("=" * 140)
print("图像矩阵的十六进制表示（非零值用红色标出）：")
data = train_dataset[0][0].squeeze().numpy()  # 获取第一张图像并转换为 numpy 数组
rows = 28
columns = 28

counter = 0
for i in range(rows):
    row = data[i * columns: (i + 1) * columns]
    for value in row:
        integer_part = int(value * 100)
        # 防止溢出 unsigned short (0~65535)
        integer_part = max(0, min(65535, integer_part))
        hex_bytes = struct.pack('H', integer_part)
        hex_string = hex_bytes.hex()
        if hex_string == '0000':
            print(hex_string + ' ', end="")
        else:
            print(f'\033[31m{hex_string}\033[0m' + " ", end="")
        counter += 1
        if counter % 28 == 0:
            print()  # 换行
print("=" * 140)

# 示例：取出第一个 batch 的数据
for images, labels in train_loader:
    print("Batch Images Shape:", images.shape)    # [batch_size, 784, 1]
    print("Batch Labels Shape:", labels.shape)    # [batch_size]

    # 显示第一张图像
    img = images[0].reshape(28, 28).numpy()
    plt.imshow(img, cmap='gray')
    plt.title(f"Label: {labels[0].item()}")
    plt.axis('off')
    plt.show()

    break  # 只显示一个 batch

三、LeNet手写数字识别

python 复制代码 
import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
from torchvision import datasets, transforms
import time
from matplotlib import pyplot as plt

pipline_train = transforms.Compose([
    # 随机旋转图片
    # MNIST 是手写数字数据集，左右翻转可能造成语义错误（例如，6 和 9 会被混淆）。所以不建议使用
    # transforms.RandomHorizontalFlip(),
    # 将图片尺寸resize到32x32
    transforms.Resize((32, 32)),
    # 将图片转化为Tensor格式
    transforms.ToTensor(),
    # 正则化(当模型出现过拟合的情况时，用来降低模型的复杂度)
    transforms.Normalize((0.1307,), (0.3081,))
])
pipline_test = transforms.Compose([
    # 将图片尺寸resize到32x32
    transforms.Resize((32, 32)),
    transforms.ToTensor(),
    transforms.Normalize((0.1307,), (0.3081,))
])
# 下载数据集
train_set = datasets.MNIST(root="./dataset", train=True, download=True, transform=pipline_train)
test_set = datasets.MNIST(root="./dataset", train=False, download=True, transform=pipline_test)
# 加载数据集
trainloader = torch.utils.data.DataLoader(train_set, batch_size=64, shuffle=True)
testloader = torch.utils.data.DataLoader(test_set, batch_size=32, shuffle=False)


# 构建LeNet模型
class LeNet(nn.Module):
    def __init__(self):
        super(LeNet, self).__init__()
        self.conv1 = nn.Conv2d(1, 6, 5)
        self.relu = nn.ReLU()
        self.maxpool1 = nn.MaxPool2d(2, 2)
        self.conv2 = nn.Conv2d(6, 16, 5)
        self.maxpool2 = nn.MaxPool2d(2, 2)
        self.fc1 = nn.Linear(16 * 5 * 5, 120)
        self.fc2 = nn.Linear(120, 84)
        self.fc3 = nn.Linear(84, 10)

    def forward(self, x):
        x = self.conv1(x)
        x = self.relu(x)
        x = self.maxpool1(x)
        x = self.conv2(x)
        x = self.maxpool2(x)
        x = x.view(-1, 16 * 5 * 5)
        x = F.relu(self.fc1(x))
        x = F.relu(self.fc2(x))
        x = self.fc3(x)
        return x


# 创建模型，部署gpu
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model = LeNet().to(device)
# 定义优化器
optimizer = optim.Adam(model.parameters(), lr=0.001)


def train_runner(model, device, trainloader, optimizer, epoch):
    model.train()
    total_loss = 0
    total_correct = 0
    total_samples = 0

    for i, (inputs, labels) in enumerate(trainloader):
        inputs, labels = inputs.to(device), labels.to(device)
        optimizer.zero_grad()
        outputs = model(inputs)
        loss = F.cross_entropy(outputs, labels)
        predict = outputs.argmax(dim=1)
        correct = (predict == labels).sum().item()

        loss.backward()
        optimizer.step()

        total_loss += loss.item()
        total_correct += correct
        total_samples += labels.size(0)

        if i % 100 == 0:
            print(f"Epoch {epoch}, Batch {i}, Loss: {loss.item():.6f}, Accuracy: {correct / labels.size(0) * 100:.2f}%")

    avg_loss = total_loss / len(trainloader)
    avg_acc = total_correct / total_samples
    print(f"Epoch {epoch} - Average Loss: {avg_loss:.6f}, Accuracy: {avg_acc * 100:.2f}%")
    return avg_loss, avg_acc


def test_runner(model, device, testloader):
    # 模型验证, 必须要写, 否则只要有输入数据, 即使不训练, 它也会改变权值
    # 因为调用eval()将不启用 BatchNormalization 和 Dropout, BatchNormalization和Dropout置为False
    model.eval()
    # 统计模型正确率, 设置初始值
    correct = 0.0
    test_loss = 0.0
    total = 0
    # torch.no_grad将不会计算梯度, 也不会进行反向传播
    with torch.no_grad():
        for data, label in testloader:
            data, label = data.to(device), label.to(device)
            output = model(data)
            test_loss += F.cross_entropy(output, label).item()
            predict = output.argmax(dim=1)
            # 计算正确数量
            total += label.size(0)
            correct += (predict == label).sum().item()
        # 计算损失值
        print("test_avarage_loss: {:.6f}, accuracy: {:.6f}%".format(test_loss / total, 100 * (correct / total)))


# 调用
epoch = 5
Loss = []
Accuracy = []
for epoch in range(1, epoch + 1):
    print("start_time", time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(time.time())))
    loss, acc = train_runner(model, device, trainloader, optimizer, epoch)
    Loss.append(loss)
    Accuracy.append(acc)
    test_runner(model, device, testloader)
    print("end_time: ", time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(time.time())), '\n')

print('Finished Training')

plt.figure(figsize=(10, 5))
plt.subplot(1, 2, 1)
plt.plot(Loss)
plt.title('Training Loss')
plt.xlabel('Epoch')
plt.ylabel('Loss')

plt.subplot(1, 2, 2)
plt.plot(Accuracy)
plt.title('Training Accuracy')
plt.xlabel('Epoch')
plt.ylabel('Accuracy')
plt.tight_layout()
plt.show()

相关推荐
cwn_4 小时前
Sequential 损失函数 反向传播 优化器 模型的使用修改保存加载
人工智能·pytorch·python·深度学习·机器学习
老鱼说AI4 小时前
Transformer Masked loss原理精讲及其PyTorch逐行实现
人工智能·pytorch·python·深度学习·transformer
lxmyzzs4 小时前
【已解决】YOLO11模型转wts时报错:PytorchStreamReader failed reading zip archive
人工智能·python·深度学习·神经网络·目标检测·计算机视觉·bug
Blossom.1184 小时前
基于深度学习的图像分类：使用预训练模型进行迁移学习
人工智能·深度学习·目标检测·分类·音视频·语音识别·迁移学习
lucky_lyovo5 小时前
循环神经网络--LSTM模型
rnn·机器学习·lstm
DO_Community6 小时前
DigitalOcean 一键模型部署，新增支持百度开源大模型ERNIE 4.5 21B
人工智能·深度学习·百度·自然语言处理·开源
go&Python8 小时前
scikit-learn 包
python·机器学习·scikit-learn
sssammmm8 小时前
AI入门学习-Python 最主流的机器学习库Scikit-learn
人工智能·python·机器学习
go54631584659 小时前
基于阿里云平台的文章评价模型训练与应用全流程指南
图像处理·人工智能·深度学习·阿里云·cnn·机器人·云计算
过往入尘土11 小时前
机器学习的基础知识
机器学习
热门推荐
01Qwen3-Coder 快速上手教程 | Qwen Code + Claude Code02全球最强模型Grok4，国内已可免费使用！（附教程）03【2025.7.18】更新vscode后所有.vue文件template标签后报红的临时解决办法，Vue - Official 插件3.0.2导致04vue数据变化但页面不变05KGG转MP3工具|非KGM文件|解密音频06Claude Code用不了？来试下Qwen3-Coder加持的Qwen Code吧07这次领先Cursor！体验了Trae 2.0 SOLO 模式，超酷！08Cursor Claude 模型无法使用的解决方法09ChatGPT Agent 完全使用指南：2025年7月最新功能详解10我亲历了2025年最荒谬的前端灾难：一支触控笔"干掉"了全球CSS预处理器