手撕深度学习：从零开始实现LeNet网络

最新推荐文章于 2024-07-09 21:10:27 发布
最新推荐文章于 2024-07-09 21:10:27 发布
阅读量1.6k 收藏 46
点赞数 55
文章标签： 深度学习 人工智能
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Nathan0921/article/details/139759917
版权
  • LeNet网络结构介绍
  • 计算前向传播
  • Jupyter笔记本代码实现
  • 项目结构代码实现
  • 小结

一、LeNet网络结构介绍

LeNet是由Yann LeCun于1998年设计，是最早的卷积神经网络之一，广泛应用于手写数字识别等任务。LeNet网络主要包含两个卷积层，两个池化层，两个全连接层，以及一个高斯连接层（现在通常用另一个全连接层替代）。这种结构的设计显著减少了网络的参数数量，同时保持了良好的特征提取能力。

二、计算前向传播

前向传播涉及数据通过网络的每一层，并进行一系列线性和非线性运算的过程。LeNet具体的操作包括卷积操作用于特征提取，激活函数（通常是ReLU或Sigmoid）增加非线性，池化层用于下采样，最后通过全连接层生成分类结果。

三、Jupyter ipynb代码实现

在Jupyter笔记本中，我们一步步构建LeNet模型，首先是导入必要的库（如TensorFlow或PyTorch），然后是定义网络结构，加载和预处理数据集（如MNIST），接着是编写训练和测试函数，最后是训练模型并绘制损失和准确率图表。

  1. 网络结构定义 
    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(1, 6, 5, stride=1, padding=2)  # 保持尺寸28x28
        self.pool1 = nn.AvgPool2d(2, 2)  # 池化后尺寸变为14x14
        self.conv2 = nn.Conv2d(6, 16, 5, stride=1, padding=0)  # 尺寸变为10x10, 池化后为5x5
        self.pool2 = nn.AvgPool2d(2, 2)  # 池化后尺寸变为5x5
        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 = F.relu(self.conv1(x))
        x = self.pool1(x)
        x = F.relu(self.conv2(x))
        x = self.pool2(x)
        x = torch.flatten(x, 1)
        x = F.relu(self.fc1(x))
        x = F.relu(self.fc2(x))
        x = self.fc3(x)
        return x
  2. 测试输入 
    # 测试代码
lenet = LeNet()
X = torch.rand(size=(1, 1, 28, 28), dtype=torch.float32)
output = lenet(X)
print("Final output shape:", output.shape)
  3. 数据预处理 
    # 2 数据预处理
from torchvision import datasets, transforms
from torch.utils.data import DataLoader
# 定义数据预处理

# 加载训练集和测试集
train_set = datasets.MNIST('./data/mnist',
                   download=True,
                   transform=transforms.Compose([
                       transforms.Resize((28, 28)),
                       transforms.ToTensor()]))
test_set = datasets.MNIST('./data/mnist',
                  train=False,
                  download=True,
                  transform=transforms.Compose([
                      transforms.Resize((28, 28)),
                      transforms.ToTensor()]))
data_train_loader = DataLoader(train_set, batch_size=256, shuffle=True, num_workers=8)
data_test_loader = DataLoader(test_set, batch_size=1024, num_workers=8)
  4. 模型加载，loss定义，优化器定义，正向传播，反向传播，训练记录，测试 
    # 3 模型加载，loss定义，优化器定义，正向传播，反向传播，训练记录，测试
import torch.optim as optim

# a. 模型读取
model = LeNet()
# b. loss定义
criterion = nn.CrossEntropyLoss()
# c. 优化器选择
optimizer = optim.Adam(model.parameters(), lr=2e-3)

# 训练模型
def train(epoch):
    model.train()
    for batch_idx, (data, targets) in enumerate(data_train_loader):
        optimizer.zero_grad()
        output = model(data)
        loss = criterion(output, targets)
        loss.backward()
        optimizer.step()
        if batch_idx % 100 == 0:
            print(f'Train Epoch: {epoch} [{batch_idx * len(data)}/{len(data_train_loader.dataset)} ({100. * batch_idx / len(data_train_loader):.0f}%)]\tLoss: {loss.item():.6f}')


# 测试模型
def test():
    model.eval()
    test_loss = 0
    correct = 0
    with torch.no_grad():
        for data, targets in data_test_loader:
            output = model(data)
            test_loss += criterion(output, targets).item()
            pred = output.argmax(dim=1, keepdim=True)
            correct += pred.eq(targets.view_as(pred)).sum().item()
    test_loss /= len(data_test_loader.dataset)
    print(f'\nTest set: Average loss: {test_loss:.4f}, Accuracy: {correct}/{len(data_test_loader.dataset)} ({100. * correct / len(data_test_loader.dataset):.0f}%)')
  5. 开始训练 
    for epoch in range(1, 16):
    train(epoch)
    test()
  6. 模型保存 
    torch.save(model.state_dict(), './model.pth')

    四、项目结构代码实现

项目代码被组织在不同的文件中，以增强代码的可维护性和可读性：

  • train.py：包含模型训练的代码。
  • lenet.py：包含LeNet模型的定义。
  • test.py：包含测试模型和处理单张图片的代码。
  • data：保存MNIST数据集的目录。
  • others：包含额外的支持文件，如模型权重保存、日志记录等。

  1. train.py文件 
    import torch
import torch.nn as nn
import torch.nn.functional as F
from torchvision import datasets, transforms
from torch.utils.data import DataLoader
import torch.optim as optim
from lenet import LeNet


# 2 数据预处理
# 加载训练集和测试集
train_set = datasets.MNIST('./data/mnist',
                   download=True,
                   transform=transforms.Compose([
                       transforms.Resize((28, 28)),
                       transforms.ToTensor()]))
test_set = datasets.MNIST('./data/mnist',
                  train=False,
                  download=True,
                  transform=transforms.Compose([
                      transforms.Resize((28, 28)),
                      transforms.ToTensor()]))
data_train_loader = DataLoader(train_set, batch_size=256, shuffle=True, num_workers=8)
data_test_loader = DataLoader(test_set, batch_size=1024, num_workers=8)




# a. 模型读取
model = LeNet()
# b. loss定义
criterion = nn.CrossEntropyLoss()
# c. 优化器选择
optimizer = optim.Adam(model.parameters(), lr=2e-3)

# 训练模型
def train(epoch):
    model.train()
    for batch_idx, (data, targets) in enumerate(data_train_loader):
        optimizer.zero_grad()
        output = model(data)
        loss = criterion(output, targets)
        loss.backward()
        optimizer.step()
        if batch_idx % 100 == 0:
            print(f'Train Epoch: {epoch} [{batch_idx * len(data)}/{len(data_train_loader.dataset)} ({100. * batch_idx / len(data_train_loader):.0f}%)]\tLoss: {loss.item():.6f}')


# 测试模型
def test():
    model.eval()
    test_loss = 0
    correct = 0
    with torch.no_grad():
        for data, targets in data_test_loader:
            output = model(data)
            test_loss += criterion(output, targets).item()
            pred = output.argmax(dim=1, keepdim=True)
            correct += pred.eq(targets.view_as(pred)).sum().item()
    test_loss /= len(data_test_loader.dataset)
    print(f'\nTest set: Average loss: {test_loss:.4f}, Accuracy: {correct}/{len(data_test_loader.dataset)} ({100. * correct / len(data_test_loader.dataset):.0f}%)')




if __name__ == '__main__':
	epoches = 20
	for epoch in range(epoches):
		train(epoch)
		test()

	# Save models
	torch.save(model.state_dict(), './model.pth')
	print('Saved PyTorch LeNet State to model.pth')

    完整的构建了整个全流程，并对模型训练loss，以及test的acc进行了图像绘制。

  2. test.py可实现单张图片测试，指定测试集测试

    """
1.导入必要的库。
2.定义或导入LeNet模型。
3. 加载训练好的模型权重。
4. 定义数据转换。
5. 定义单张图片的测试函数。
6. 定义测试集评估函数。
7. 执行测试。

"""

import torch
import torch.nn.functional as F
from torchvision import datasets, transforms
from torchvision.transforms import ToPILImage
from torch.utils.data import DataLoader
from PIL import Image
import random
import matplotlib.pyplot as plt
from lenet import LeNet  # 确保lenet模块中包含了LeNet的定义

# 设定设备
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

# 定义数据转换
transform = transforms.Compose([
    transforms.Resize((28, 28)),
    transforms.ToTensor()
])

# 加载模型
model = LeNet().to(device)
model.load_state_dict(torch.load('./model.pth'))
model.eval()

def visual_random_images(dataset, num_images=10):
    indices = random.sample(range(len(dataset)), num_images)
    images = [dataset[i][0] for i in indices]
    labels = [dataset[i][1] for i in indices]

    for idx, (image, label) in enumerate(zip(images, labels)):
        plt.figure()
        plt.imshow(ToPILImage()(image), cmap='gray')
        plt.title(f'Label: {label}')
        plt.savefig(f'./random_image/image_{idx}.png')  # 保存图片
        plt.close()


def save_random_images(dataset, num_images=10):
    indices = random.sample(range(len(dataset)), num_images)
    images = [dataset[i][0] for i in indices]
    labels = [dataset[i][1] for i in indices]

    for idx, (image, label) in enumerate(zip(images, labels)):
        img = ToPILImage()(image)
        img.save(f'./random_image/random_image_{idx}_label_{label}.png')

def test_single_image(image_path):
    image = Image.open(image_path)
    image = transform(image).unsqueeze(0).to(device)  # 转换并添加batch维度

    with torch.no_grad():
        output = model(image)
        predicted = output.argmax(dim=1)

    # 显示图像及预测结果
    plt.imshow(ToPILImage()(image.squeeze(0)), cmap='gray')
    plt.title(f'Predicted: {predicted.item()}')
    plt.show()

def evaluate_accuracy(data_loader):
    correct = 0
    total = 0
    with torch.no_grad():
        for data, targets in data_loader:
            data, targets = data.to(device), targets.to(device)
            outputs = model(data)
            _, predicted = torch.max(outputs.data, 1)
            total += targets.size(0)
            correct += (predicted == targets).sum().item()

    accuracy = 100 * correct / total
    print(f'Accuracy of the network on the test images: {accuracy:.2f}%')

if __name__ == '__main__':
    

    # 评估测试集
    test_set = datasets.MNIST('./data/mnist', train=False, download=True, transform=transform)
    test_loader = DataLoader(test_set, batch_size=1024, shuffle=False)
    evaluate_accuracy(test_loader)

    save_random_images(test_set, num_images=10)

    # 测试单张图片
    # 保存随机选取的图片
    
    test_single_image('./random_image/random_image_0_label_7.png')  # 替换为实际图片路径

五、小结

在这篇博客中，我们详细讲解了如何从理论到实践完整地实现一个LeNet模型。通过逐步介绍每个组成部分的作用和实现，读者可以更好地理解深度学习项目的构建过程。此外，我们也展示了如何将这些知识应用到实际代码和项目结构中，帮助读者构建自己的神经网络项目。

Reference

未提及部分

  1.  详细手撕网络结构
  2.  pytorch自定义卷积、池化、padding、loss计算、优化器对比
  3.  数学定义卷积、池化、padding、loss计算、优化器对比
  4. 以上三点甚至比简单构建整个手撕过程更重要，更重要，更重要
Nathan0921
关注
TF2.0深度学习实战（七）：手撕深度残差网络ResNet
不积跬步，无以至千里！
04-19 1万+
手把手带你搭建网络模型，实现图像分类与目标检测。大神勿扰~
深度学习技巧应用24-深度学习手撕代码与训练流程的联系记忆方法
weixin_42878111的博客
07-30 620
大家好，我是微学AI，今天给大家介绍一下深度学习技巧应用24-深度学习手撕代码与训练流程的联系记忆方法，大家都知道深度学习模型训练过程是个复杂的过程，这个过程包括数据的收集，数据的处理，模型的搭建，优化器的选择，损失函数的选择，模型训练，模型评估等步骤，其中缺少一个环节模型就无法训练，本文编写目的是为了给大家更好的理解和记忆模型训练的全过程，利用虚拟数据快速上手训练，记忆深度学习手撕代码与训练流程的联系需要理解基本概念、学习代码实现、掌握常用框架和工具、理解训练流程，并通过反复实践与总结来提高编码和训练的能
【深度学习】LeNet原理及代码实现
最新发布
言兼小师傅的博客
07-09 570
【代码】LeNet原理及代码实现。
手撕python_Pytorch手撕经典网络之LeNet5
weixin_39750731的博客
11-28 259
下图为经典网络LeNet5的网络结构。实现时，主要包括俩个卷积层，俩个pooling层，三个全连接层（严格来说，最后一层的Gaussian connection应有其它的转化方式，这里用全连接）。这里面采用了mnist数据集，但为了更深入的学习pytorch，所以这里采用了自定义数据源的方式。下面一段代码为加载mnist数据集，主要是解析二进制文件转成numpy格式数据的过程。数据集是从mnist...
深度学习实践4：手撕卷积神经网络
white_0629的博客
09-05 341
本部分实现了一个简单的二维卷积神经网络（Conv2D），并进行了简单的实践，以下是代码流程。
手撕卷积神经网络CNN【附代码】
qq_35874169的博客
12-28 2501
手撕卷积神经网络CNN 博主接触CNN已有一段时间，写这篇博客一方面是为了加深自己的理解及记忆，另一方面是给初学者以启发，同时也便于大家一起交流学习。 1.CNN发展史 简单来说，CNN经过以下的发展史： 1.CNN的起源 1980年代末-1999年 ConvNet、LeNet-5 2.CNN停滞不前 2000年初 性能很难改...
手撕卷积神经网络历险记 三、padding操作图解
Willen_的博客
08-24 410
手撕卷积神经网络历险记 三、padding操作图解   由于之前做了公众号版本，所以直接附上链接，可以直接点开查看 欢迎关注公众号一起交流！   基于上一篇，卷积前向传播c++实现 我们开始讲解padding，链接如下： https://mp.weixin.qq.com/s?__biz=MzU4NTU5MzAzNw==&mid=2247483703&idx=1&amp...
手撕神经网络：从零开始实现一个简单的神经网络（python）
生命在于折腾！
11-14 2148
手撕神经网络：从零开始实现一个简单的神经网络 1. 前言 现在有很多深度学习平台可以用，甚至我们根本不需要知道网络背后是怎么运行的，就可以训练出我们想要的模型，但是从学习的角度，从零开始写一个简单的神经网络是有必要的，它将有助于理解神经网络的工作原理。 之前有写过基于 TF 的全连接神经网络的实现，可以参考深度学习笔记——全连接神经网络样例程序及详细注释。但是这里将不借助任何深度学习平台来实现一个...
手撕Transformer模型从零实现
05-13
本资源提供了Transformer模型的详细代码实现，旨在通过透彻的解析和精心的注释，使学习者能够深刻理解其背后的原理和技术细节。 主要特性： 深度解析：代码中每一部分都有详尽的注释，解释了每个函数和类的作用及其...
C语言手撕机器学习深度学习算法.zip
10-19
C语言手撕机器学习深度学习算法.zip
手撕CNN卷积神经网络原理（一）
debby233的博客
08-16 2293
我们常见的比较简单的神经网络如下图所示对于该神经网络，有以下感念1.输入层（input layer），可以理解为数学中线性函数 y=kx+b 中的若干个x2.权重w（weights）：可以理解为数学中线性函数 y=kx+b 中的 k3.偏执量b（bias）：可以理解为数学中线性函数 y=kx+b 中的 b4.a：可以理解为数学中线性函数 y=kx+b 中的y，但这个y不是该节点输出的结果。...
手撕卷积神经网络历险记 一、卷积前向传播图解
Willen_的博客
08-24 742
手撕卷积神经网络历险记 一、卷积前向传播图解   毕设做的是关于卷积神经网络的车标分类，然后就用python手撕了一下，实现的过程很坎坷，也很幸运，在这里做一下记录，同时也希望能和志同道合的朋友多多交流！！ 本人将会把自己的实现过程的整个经历进行分享，并再用c++复现，完结之时将会附上源码 将每个过程的实现细节以及注意点在这里记录。 由于之前做了公众号版本，所以直接附上链接，可以直接点开...
手撕 | 深度神经网络卷积层计算加速与优化
小白学视觉
12-26 411
点击上方“小白学视觉”，选择加"星标"或“置顶”重磅干货，第一时间送达阅读本文大概需要 6 min左右传统卷积层计算01首先我们定义符号F（）函数为卷积函数一维卷积：F（n，m）n代表输出的维度，m代表滤波器的维度二维卷积：F（n*m，r*s）n*m代表输出的维度，r*s代表滤波器的维度下面我们具体谈谈针对二维的卷积加速传统的卷积层加速：对于最简单的F（n*m，r*s）最传统暴力的卷积运算：时...
神经网络必面之手撕 —— IOU、NMS、正向卷积、池化、BN【持续更新】
weixin_44398263的博客
03-10 9073
一、IOU： import numpy as np def ComputeIOU(boxA, boxB): ## 计算相交框的坐标 x1 = np.max([boxA[0], boxB[0]]) x2 = np.min([boxA[2], boxB[2]]) y1 = np.max([boxA[1], boxB[1]]) y2 = np.min([boxA[3], boxB[3]]) ## 计算交区域，并区域，及IOU interAre
手撕Resnet卷积神经网络-pytorch-详细注释版（可以直接替换自己数据集）-直接放置自己的数据集就能直接跑。跑的代码有问题的可以在评论区指出，看到了会回复。训练代码和预测代码均有。
爱吃橘子的小翟
03-26 3万+
导入库： import torch import torchvision import torchvision.models import os from matplotlib import pyplot as plt from tqdm import tqdm from torch import nn from torch.utils.data import DataLoader from torchvision.transforms import transforms 图像预处理： 将图像放缩成
深度学习 --- 卷积神经网络CNN（LeNet-5网络学习算法详解）
进击的菜鸟
11-27 1万+
上一节我们详细探讨了LeNet-5网络的架构，但是还没有解释该网络是如何进行学习的，如何更新权值的，本节将接着上一节进一步CNN的学习机制和权值更新过程，这里请大家一定要对CNN网络有一个清晰的认识，知道每一层是做什么的，为什么这样设置。原因在哪等。大家在学习的过程中需要多问自己几个为什么，这样才能快速进步的，好，废话不多说，开始今天的内容：         我们知道了CNN其实主要组成部分为卷...
深度学习 --- 卷积神经网络CNN（LeNet-5网络详解）
热门推荐
进击的菜鸟
11-26 23万+
卷积神经网络（Convolutional Neural Network，CNN）是一种前馈型的神经网络，其在大型图像处理方面有出色的表现，目前已经被大范围使用到图像分类、定位等领域中。相比于其他神经网络结构，卷积神经网络需要的参数相对较少，使的其能够广泛应用。 本节打算先介绍背景和简单的基本概念术语，然后详细介绍LeNet-5网络，其工作流程大家需要先搞清楚，学习原理其实是基于BP学习原理的，只...
手撕Alexnet卷积神经网络-pytorch-详细注释版（可以直接替换自己数据集）-直接放置自己的数据集就能直接跑。跑的代码有问题的可以在评论区指出，看到了会回复。训练代码和预测代码均有。
爱吃橘子的小翟
03-15 1万+
详细注释alexnet代码
手撕系列：原生python实现卷积神经网络
qq_43409114的博客
04-25 6943
前言 之前就一直想不调用框架，实现一个CNN和RNN，实现这两种网络的主要难度就在于反向传播，对与CNN来说反向传播也要涉及到卷积，对于RNN来说反向传播会涉及到沿时间序列进行传播，也就是BPTT。在此过程中遇到不少困难，踩了不少坑，所以写此博文总结一下。 实现卷积神经网络 我们这里要实现的卷积神经网络是Lenet-5模型，其模型结构图如下 其网络结构用语言描述的话，就是: 输入层->卷积...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值