基于PyTorch实现LeNet、AlexNet、ResNet完成MNIST手写字体识别任务

已于 2024-01-18 13:31:15 修改
阅读量976 收藏 16
点赞数 3
文章标签： pytorch 深度学习 人工智能 机器学习 神经网络
于 2023-05-01 00:11:29 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yongyi_/article/details/130452955
版权
本文详细介绍了如何使用PyTorch实现LeNet、AlexNet和ResNet三种卷积神经网络，对MNIST手写数字数据集进行识别。通过数据预处理、模型构建、训练和评估，展示了不同网络结构对模型性能的影响，并对PyTorch与其他自定义深度学习框架的差异进行了比较。实验结果表明，网络结构的调整可以影响模型的训练效果和收敛速度。
摘要由CSDN通过智能技术生成

基于PyTorch实现LeNet、AlexNet、ResNet完成MNIST手写字体识别任务

引言

​ 本文基于PyTorch实现LeNet、AlexNet、ResNet完成MNIST手写字体识别任务。1节中说明了数据集的处理方法，2节说明了算法的设计思路，3节给出了LeNet、AlexNet、ResNet的实现代码，最后分析了采用Pytorch框架与自己手写的深度学习框架的不同，4节中对各个卷积网络进行训练，给出了训练结果和可视化结果，其中对LeNet网络结构进行了一些不同的调整和训练，5节中是本项目的一些总结，文末在附录中给出了本项目的所有代码。

1 数据集

​ 简便起见，直接使用torchvision.datasets中封装好的MNIST()来加载MNIST的ubyte格式的数据集，定义数据集加载函数load_data_mnist，代码如下：

def load_data_mnist(batch_size, resize=None):
    num_workers = 4
    trans = [transforms.ToTensor()]
    if resize:
        trans.insert(0, transforms.Resize(resize))
    trans = transforms.Compose(trans)
    mnist_train = torchvision.datasets.MNIST(root="../data", train=True, transform=trans, download=True)
    mnist_test = torchvision.datasets.MNIST(root="../data", train=False, transform=trans, download=True)
    return (data.DataLoader(mnist_train, batch_size, shuffle=True, num_workers=num_workers),
            data.DataLoader(mnist_test, batch_size, shuffle=False, num_workers=num_workers))

2 算法设计

2.1 train_one_epoch

​ 定义train_one_epoch函数，实现对所有数据的一次训练迭代，返回该次迭代的训练损失和数据集ACC，代码如下：

def train_one_epoch(net, train_iter, device, optimizer, loss):
    train_l = 0.0
    train_ac = 0.0
    cnt = 0
    for i, (X, y) in enumerate(train_iter):
        net.train()
        optimizer.zero_grad()
        X, y = X.to(device), y.to(device)
        y_hat = net(X)
        l = loss(y_hat, y)
        l.backward()
        optimizer.step()

        train_l += l.item()
        train_ac += torch.sum((torch.argmax(y_hat, dim=1) == y)).item()
        cnt += len(y)

    return train_l/len(train_iter), train_ac/cnt

2.2 evaluate_accuracy

​ 定义evaluate_accuracy函数，以对每一次调用完train_one_epoch函数后，对测试集（验证集）进行模型ACC的评估并返回，代码实现如下：

def evaluate_accuracy(net, data_iter, device=None):
    net.eval()
    if not device:
        device = next(iter(net.parameters())).device
    ac, cnt = 0.0, 0
    for X, y in data_iter:
        X, y = X.to(device), y.to(device)
        Z = torch.argmax(net(X), dim=1)
        ac += torch.sum(Z == y).item()
        cnt += len(y)
    return ac/cnt

2.3 train

​ 定义train函数，实现对模型整个训练过程的控制，首先对网络的卷积和全连接层采用xavier初始化，定义优化器、损失函数，随后进行num_epochs次训练迭代，对每个epoch的迭代，依次调用train_one_epoch函数和evaluate_accuracy函数并记录训练过程，最后用matplotlib对训练过程可视化，具体的实现代码如下；

def train(net, train_iter, test_iter, num_epochs, lr, device):
    def init_weights(m):
        if type(m) == nn.Linear or type(m) == nn.Conv2d:
            torch.nn.init.xavier_uniform_(m.weight)
    net.apply(init_weights)

    print('training on', device)
    net.to(device)
    optimizer = torch.optim.SGD(net.parameters(), lr=lr)
    loss = nn.CrossEntropyLoss()

    # 用来保存训练以及验证过程中信息
    results_file = "results{}.txt".format(datetime.datetime.now().strftime("%Y%m%d-%H%M%S"))

    trl, tra, tea = [], [], []
    for epoch in range(num_epochs):
        train_l, train_acc = train_one_epoch(net, train_iter, device, optimizer, loss)
        test_acc = evaluate_accuracy(net, test_iter, device)
        trl.append(train_l), tra.append(train_acc), tea.append(test_acc)
        # print(epoch, train_l, train_acc, test_acc)
        with open(results_file, "a") as f:
            f.write(f'epoch {epoch}  loss {train_l:.3f}, train acc {train_acc:.3f}, test acc {test_acc:.3f} \n')

    print(f'epoch {epoch}  loss {train_l:.3f}, train acc {train_acc:.3f}, test acc {test_acc:.3f} \n')

    plt.xlabel = 'epoch'
    xlim = range(0, num_epochs)
    legend = ['train loss', 'train acc', 'test acc']
    plt.plot(xlim, trl, linewidth=1, color='purple')
    plt.plot(xlim, tra, linewidth=1, color='green', linestyle='--')
    plt.plot(xlim, tea, linewidth=1, color='blue', linestyle='--')
    plt.legend(legend, ncol=4)
    plt.grid(axis='y', linewidth=0.3)
    plt.xticks(range(0, num_epochs, 2))
    plt.show()

2.4 程序入口

​ 以LeNet为例，定义好批大小batch_size、 学习率lr、迭代次数num_epochs、调用load_data_mnist函数加载数据集得到train_iter, test_iter，再把这些参数传入train函数即可，代码如下，其中try_gpu函数用于检验cuda是否可用：

if __name__ == '__main__':

    def try_gpu():
        if torch.cuda.device_count() >= 1:
            return torch.device('cuda:0')
        return torch.device('cpu')

    net = LeNet5
    batch_size = 256
    train_iter, test_iter = load_data_mnist(batch_size=batch_size)
    lr, num_epochs = 0.9, 10
    train(net, train_iter, test_iter, num_epochs, lr, try_gpu())

3 模型实现

3.1 LeNet

​ 搭建LeNet模型的代码如下：

import torch
from torch import nn
from torch.nn import functional as F

LeNet5 = nn.Sequential(
    nn.Conv2d(1, 6, kernel_size=5, padding=2), nn.Sigmoid(),
    nn.AvgPool2d(kernel_size=2, stride=2),
    nn.Conv2d(6, 16, kernel_size=5), nn.Sigmoid(),
    nn.AvgPool2d(kernel_size=2, stride=2),
    nn.Flatten(),
    nn.Linear(16 * 5 * 5, 120), nn.Sigmoid(),
    nn.Linear(120, 84), nn.Sigmoid(),
    nn.Linear(84, 10))

3.2 AlexNet

​ 搭建AlexNet模型的代码如下：

AlexNet = nn.Sequential(
    nn.Conv2d(1, 96, kernel_size=11, stride=4, padding=1), nn.ReLU(),
    nn.MaxPool2d(kernel_size=3, stride=2),
    nn.Conv2d(96, 256, kernel_size=5, padding=2), nn.ReLU(),
    nn.MaxPool2d(kernel_size=3, stride=2),
    nn.Conv2d(256, 384, kernel_size=3, padding=1), nn.ReLU(),
    nn.Conv2d(384, 384, kernel_size=3, padding=1), nn.ReLU(),
    nn.Conv2d(384, 256, kernel_size=3, padding=1), nn.ReLU(),
    nn.MaxPool2d(kernel_size=3, stride=2),
    nn.Flatten(),
    nn.Linear(6400, 4096), nn.ReLU(),
    nn.Dropout(p=0.5),
    nn.Linear(4096, 4096), nn.ReLU(),
    nn.Dropout(p=0.5),
    nn.Linear(4096, 10))

3.3 ResNet

​ 搭建ResNet模型的代码如下：

class Residual(nn.Module):
    def __init__(self, input_channels, num_channels,use_1x1conv=False, strides=1):
        super().__init__()
        self.conv1 = nn.Conv2d(input_channels, num_channels,kernel_size=3, padding=1, stride=strides)
        self.conv2 = nn.Conv2d(num_channels, num_channels,kernel_size=3, padding=1)
        if use_1x1conv:
            self.conv3 = nn.Conv2d(input_channels, num_channels,
            kernel_size=1, stride=strides)
        else:
            self.conv3 = None
        self.bn1 = nn.BatchNorm2d(num_channels)
        self.bn2 = nn.BatchNorm2d(num_channels)

    def forward(self, X):
        Y = F.relu(self.bn1(self.conv1(X)))
        Y = self.bn2(self.conv2(Y))
        if self.conv3:
            X = self.conv3(X)
        Y += X
        return F.relu(Y)


b1 = nn.Sequential(nn.Conv2d(1, 64, kernel_size=7, stride=2, padding=3),
    nn.BatchNorm2d(64), nn.ReLU(),
    nn.MaxPool2d(kernel_size=3, stride=2, padding=1))


def resnet_block(input_channels, num_channels, num_residuals,
    first_block=False):
    blk = []
    for i in range(num_residuals):
        if i == 0 and not first_block:
            blk.append(Residual(input_channels, num_channels,use_1x1conv=True, strides=2))
        else:
            blk.append(Residual(num_channels, num_channels))
    return blk


b2 = nn.Sequential(*resnet_block(64, 64, 2, first_block=True))
b3 = nn.Sequential(*resnet_block(64, 128, 2))
b4 = nn.Sequential(*resnet_block(128, 256, 2))
b5 = nn.Sequential(*resnet_block(256, 512, 2))

ResNet18 = nn.Sequential(b1, b2, b3, b4, b5,
        nn.AdaptiveAvgPool2d((1,1)),
        nn.Flatten(), nn.Linear(512, 10))

3.4 简要说明PyTorch框架与作业02的不同

​ 我认为PyTorch框架与自己手写的精简版深度框架最不大区别同是以下5点：

​ 1) PyTorch能够调用GPU进行矩阵的快速运算，使得神经网络训练迅速；

​ 2) PyTorch功能齐全，激活函数，优化器，损失函数，初始化方法等很齐全，配套的其他库也很多;

​ 3) PyTorch生态好，使用者众多，能在网络中快速找到问题的解决办法;

​ 4) PyTorch能够自动计算梯度，模块化设计得很好，搭建模型十分方便;

​ 5) PyTorch一直在更新，能够不断适应最新的深度学习模型，如图神经网络等。

4 模型训练及结果

4.1 训练LeNet

4.1.1 使用原始的LeNet5的网络结构进行训练

​ 训练的一些参数如下：

	net = LeNet5
    batch_size = 256
    train_iter, test_iter = load_data_mnist(batch_size=batch_size)
    lr, num_epochs = 0.6, 20
    optimizer = torch.optim.SGD(net.parameters(), lr=lr)
    loss = nn.CrossEntropyLoss()

​ 训练最终结果：[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-jkIBN831-1682870518342)(E:/typora-image/image-20230430210026789.png)]

​ 训练过程可视化如下：

在这里插入图片描述

4.1.2 调整LeNet5的网络结构进行训练

​ 本小节模型训练所需参数与4.1.1节中的保持不变，尝试改变卷积核大小、输出通道数、激活函数、卷积层或全连接层数量进行训练。

4.1.2.1 调整卷积核大小

​ 将LeNet5中卷积非池化层的卷积核大小改为3。

	kernel_size=3

​ 训练最终结果：[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-X4SnO5KM-1682870518344)(E:/typora-image/image-20230430230814355.png)]

​ 训练过程可视化如下：

在这里插入图片描述

4.1.2.2 调整输出通道数

​ 将LeNet5中卷积层的输出通道数改为原来的一半。

	nn.Conv2d(1, 6//2, kernel_size=5, padding=2) # 卷积层1
    nn.Conv2d(6//2, 16//2, kernel_size=5) # 卷积层2

​ 训练最终结果：
![在这里插入图片描述](https://img-blog.csdnimg.cn/0b93b74f16534f2ea033dffe2dba8eb3.png#pic_center

​ 训练过程可视化如下：

在这里插入图片描述

4.1.2.3 调整激活函数

​ 将LeNet5中的sigmoid激活函数换成ReLU。

​ 训练最终结果：[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Y2EdJg6A-1682870518346)(E:/typora-image/image-20230430235456762.png)]

​ 训练过程可视化如下：
在这里插入图片描述

4.1.2.4 调整卷积层或全连接层数量

​ 减少卷积层与全连接层数量，均减少为1。

    LeNet5_04 = nn.Sequential(
        nn.Conv2d(1, 16, kernel_size=5, padding=2), nn.Sigmoid(),
        nn.AvgPool2d(kernel_size=2, stride=2),
        nn.Flatten(),
        nn.Linear(3136, 10))

​ 训练最终结果：![在这里插入图片描述](https://img-blog.csdnimg.cn/d767d779c8a247a885227f90038d7fbc.png#pic_center

​ 训练过程可视化如下：

在这里插入图片描述

4.2 训练AlexNet

​ 训练的一些参数如下：

    net = AlexNet
    batch_size = 128
    train_iter, test_iter = load_data_mnist(batch_size=batch_size, resize=224)
    lr, num_epochs = 0.01, 10
    optimizer = torch.optim.SGD(net.parameters(), lr=lr)
    loss = nn.CrossEntropyLoss()

​ 训练最终结果：[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-RLA2zfeb-1682870518347)(E:/typora-image/image-20230430220326417.png)]

​ 训练过程可视化如下：

在这里插入图片描述

4.3 训练ResNet

​ 训练的一些参数如下：

    net = ResNet18
    batch_size = 256
    train_iter, test_iter = load_data_mnist(batch_size=batch_size, resize=96)
    lr, num_epochs = 0.05, 10
    optimizer = torch.optim.SGD(net.parameters(), lr=lr)
    loss = nn.CrossEntropyLoss()

​ 训练最终结果：[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-psJMwZGW-1682870518348)(E:/typora-image/image-20230430222303506.png)]

​ 训练过程可视化如下：

在这里插入图片描述

5 小结

​ 从4中结果可以看出，不同的网络结果将对模型的训练效果有影响，其次，模型越复杂，其收敛速度越快，精度越高。最后：PyTorch很好用。

附录

​ 完整代码

model.py

import torch
from torch import nn
from torch.nn import functional as F

LeNet5 = nn.Sequential(
    nn.Conv2d(1, 6, kernel_size=5, padding=2), nn.Sigmoid(),
    nn.AvgPool2d(kernel_size=2, stride=2),
    nn.Conv2d(6, 16, kernel_size=5), nn.Sigmoid(),
    nn.AvgPool2d(kernel_size=2, stride=2),
    nn.Flatten(),
    nn.Linear(16 * 5 * 5, 120), nn.Sigmoid(),
    nn.Linear(120, 84), nn.Sigmoid(),
    nn.Linear(84, 10))

LeNet5_01 = nn.Sequential(
    nn.Conv2d(1, 6, kernel_size=3, padding=2), nn.Sigmoid(),
    nn.AvgPool2d(kernel_size=2, stride=2),
    nn.Conv2d(6, 16, kernel_size=3), nn.Sigmoid(),
    nn.AvgPool2d(kernel_size=2, stride=2),
    nn.Flatten(),
    nn.Linear(576, 120), nn.Sigmoid(),
    nn.Linear(120, 84), nn.Sigmoid(),
    nn.Linear(84, 10))

LeNet5_02 = nn.Sequential(
    nn.Conv2d(1, 6//2, kernel_size=5, padding=2), nn.Sigmoid(),
    nn.AvgPool2d(kernel_size=2, stride=2),
    nn.Conv2d(6//2, 16//2, kernel_size=5), nn.Sigmoid(),
    nn.AvgPool2d(kernel_size=2, stride=2),
    nn.Flatten(),
    nn.Linear(16//2 * 5 * 5, 120), nn.Sigmoid(),
    nn.Linear(120, 84), nn.Sigmoid(),
    nn.Linear(84, 10))

LeNet5_03 = nn.Sequential(
    nn.Conv2d(1, 6, kernel_size=5, padding=2), nn.ReLU(),
    nn.AvgPool2d(kernel_size=2, stride=2),
    nn.Conv2d(6, 16, kernel_size=5), nn.ReLU(),
    nn.AvgPool2d(kernel_size=2, stride=2),
    nn.Flatten(),
    nn.Linear(16 * 5 * 5, 120), nn.ReLU(),
    nn.Linear(120, 84), nn.ReLU(),
    nn.Linear(84, 10))

LeNet5_04 = nn.Sequential(
    nn.Conv2d(1, 16, kernel_size=5, padding=2), nn.Sigmoid(),
    nn.AvgPool2d(kernel_size=2, stride=2),
    nn.Flatten(),
    nn.Linear(3136, 10))

AlexNet = nn.Sequential(
    nn.Conv2d(1, 96, kernel_size=11, stride=4, padding=1), nn.ReLU(),
    nn.MaxPool2d(kernel_size=3, stride=2),
    nn.Conv2d(96, 256, kernel_size=5, padding=2), nn.ReLU(),
    nn.MaxPool2d(kernel_size=3, stride=2),
    nn.Conv2d(256, 384, kernel_size=3, padding=1), nn.ReLU(),
    nn.Conv2d(384, 384, kernel_size=3, padding=1), nn.ReLU(),
    nn.Conv2d(384, 256, kernel_size=3, padding=1), nn.ReLU(),
    nn.MaxPool2d(kernel_size=3, stride=2),
    nn.Flatten(),
    nn.Linear(6400, 4096), nn.ReLU(),
    nn.Dropout(p=0.5),
    nn.Linear(4096, 4096), nn.ReLU(),
    nn.Dropout(p=0.5),
    nn.Linear(4096, 10))


class Residual(nn.Module):
    def __init__(self, input_channels, num_channels,use_1x1conv=False, strides=1):
        super().__init__()
        self.conv1 = nn.Conv2d(input_channels, num_channels,kernel_size=3, padding=1, stride=strides)
        self.conv2 = nn.Conv2d(num_channels, num_channels,kernel_size=3, padding=1)
        if use_1x1conv:
            self.conv3 = nn.Conv2d(input_channels, num_channels,
            kernel_size=1, stride=strides)
        else:
            self.conv3 = None
        self.bn1 = nn.BatchNorm2d(num_channels)
        self.bn2 = nn.BatchNorm2d(num_channels)

    def forward(self, X):
        Y = F.relu(self.bn1(self.conv1(X)))
        Y = self.bn2(self.conv2(Y))
        if self.conv3:
            X = self.conv3(X)
        Y += X
        return F.relu(Y)


b1 = nn.Sequential(nn.Conv2d(1, 64, kernel_size=7, stride=2, padding=3),
    nn.BatchNorm2d(64), nn.ReLU(),
    nn.MaxPool2d(kernel_size=3, stride=2, padding=1))


def resnet_block(input_channels, num_channels, num_residuals,
    first_block=False):
    blk = []
    for i in range(num_residuals):
        if i == 0 and not first_block:
            blk.append(Residual(input_channels, num_channels,use_1x1conv=True, strides=2))
        else:
            blk.append(Residual(num_channels, num_channels))
    return blk


b2 = nn.Sequential(*resnet_block(64, 64, 2, first_block=True))
b3 = nn.Sequential(*resnet_block(64, 128, 2))
b4 = nn.Sequential(*resnet_block(128, 256, 2))
b5 = nn.Sequential(*resnet_block(256, 512, 2))

ResNet18 = nn.Sequential(b1, b2, b3, b4, b5,
        nn.AdaptiveAvgPool2d((1,1)),
        nn.Flatten(), nn.Linear(512, 10))

main.py

import datetime
import matplotlib.pylab as plt
import torch
import torchvision
from torch import nn
from torch.utils import data
from torchvision import transforms
from model import LeNet5, AlexNet, ResNet18, LeNet5_01, LeNet5_02, LeNet5_03, LeNet5_04


def load_data_mnist(batch_size, resize=None):
    num_workers = 4
    trans = [transforms.ToTensor()]
    if resize:
        trans.insert(0, transforms.Resize(resize))
    trans = transforms.Compose(trans)
    mnist_train = torchvision.datasets.MNIST(root="../data", train=True, transform=trans, download=True)
    mnist_test = torchvision.datasets.MNIST(root="../data", train=False, transform=trans, download=True)
    return (data.DataLoader(mnist_train, batch_size, shuffle=True, num_workers=num_workers),
            data.DataLoader(mnist_test, batch_size, shuffle=False, num_workers=num_workers))


def evaluate_accuracy(net, data_iter, device=None):
    net.eval()
    if not device:
        device = next(iter(net.parameters())).device
    ac, cnt = 0.0, 0
    for X, y in data_iter:
        X, y = X.to(device), y.to(device)
        Z = torch.argmax(net(X), dim=1)
        ac += torch.sum(Z == y).item()
        cnt += len(y)
    return ac/cnt


def train_one_epoch(net, train_iter, device, optimizer, loss):
    train_l = 0.0
    train_ac = 0.0
    cnt = 0
    for i, (X, y) in enumerate(train_iter):
        net.train()
        optimizer.zero_grad()
        X, y = X.to(device), y.to(device)
        y_hat = net(X)
        l = loss(y_hat, y)
        l.backward()
        optimizer.step()

        train_l += l.item()
        train_ac += torch.sum((torch.argmax(y_hat, dim=1) == y)).item()
        cnt += len(y)

    return train_l/len(train_iter), train_ac/cnt


def train(net, train_iter, test_iter, num_epochs, lr, device):
    def init_weights(m):
        if type(m) == nn.Linear or type(m) == nn.Conv2d:
            torch.nn.init.xavier_uniform_(m.weight)
    net.apply(init_weights)

    print('training on', device)
    net.to(device)
    optimizer = torch.optim.SGD(net.parameters(), lr=lr)
    loss = nn.CrossEntropyLoss()

    # 用来保存训练以及验证过程中信息
    results_file = "results{}.txt".format(datetime.datetime.now().strftime("%Y%m%d-%H%M%S"))

    trl, tra, tea = [], [], []
    for epoch in range(num_epochs):
        train_l, train_acc = train_one_epoch(net, train_iter, device, optimizer, loss)
        test_acc = evaluate_accuracy(net, test_iter, device)
        trl.append(train_l), tra.append(train_acc), tea.append(test_acc)
        # print(epoch, train_l, train_acc, test_acc)
        with open(results_file, "a") as f:
            f.write(f'epoch {epoch}  loss {train_l:.3f}, train acc {train_acc:.3f}, test acc {test_acc:.3f} \n')

    print(f'epoch {epoch}  loss {train_l:.3f}, train acc {train_acc:.3f}, test acc {test_acc:.3f} \n')

    plt.xlabel = 'epoch'
    xlim = range(0, num_epochs)
    legend = ['train loss', 'train acc', 'test acc']
    plt.plot(xlim, trl, linewidth=1, color='purple')
    plt.plot(xlim, tra, linewidth=1, color='green', linestyle='--')
    plt.plot(xlim, tea, linewidth=1, color='blue', linestyle='--')
    plt.legend(legend, ncol=4)
    plt.grid(axis='y', linewidth=0.3)
    plt.xticks(range(0, num_epochs, 2))
    plt.show()


if __name__ == '__main__':

    def try_gpu():
        if torch.cuda.device_count() >= 1:
            return torch.device('cuda:0')
        return torch.device('cpu')

    net = LeNet5
    batch_size = 256
    train_iter, test_iter = load_data_mnist(batch_size=batch_size)
    lr, num_epochs = 0.6, 20
    train(net, train_iter, test_iter, num_epochs, lr, try_gpu())

    # net = AlexNet
    # batch_size = 128
    # train_iter, test_iter = load_data_mnist(batch_size=batch_size, resize=224)
    # lr, num_epochs = 0.01, 10
    # train(net, train_iter, test_iter, num_epochs, lr, try_gpu())

    # net = ResNet18
    # batch_size = 256
    # train_iter, test_iter = load_data_mnist(batch_size=batch_size, resize=96)
    # lr, num_epochs = 0.05, 10
    # train(net, train_iter, test_iter, num_epochs, lr, try_gpu())

参考文献

[1] 胡晓武等．智能之门：神经网络与深度学习入门：基于Python〔M〕．北京∶高等教育出版社，2020.12 ;

永乙
关注
【图像分类】基于PyTorch搭建卷积神经网络实现MNIST手写数字识别(附项目完整代码)
学无止境、积少成多、厚积薄发
02-16 970
基于PyTorch搭建卷积神经网络实现MNIST手写数字识别(附项目完整代码)
【图像分类】卷积神经网络之LeNet5网络模型实现MNIST手写数字识别
学无止境、积少成多、厚积薄发
02-21 1138
卷积神经网络之LeNet5网络模型实现MNIST手写数字识别，文末附完整项目代码和数据集
AlexNet MNIST Pytorch
xuan_liu123的博客
04-08 7710
AlexNet Pytorch实现，在MNIST上测试 AlexNet简介 ILSVRC 2012的冠军网络,60M参数。网络基本架构为：conv1 (96) -> pool1 -> conv2 (256) -> pool2 -> conv3 (384) -> conv4 (384) -> conv5 (256) -> pool5 -> fc6 (4...
Pytorch--ResNet识别MNIST数据集
不加辣椒的博客
06-27 6510
之前搭建了ResNet网络架构，所以用其识别MNIST数据集。 1、由于电脑的运行内存，在设计网络结构时，用了8层网络，分别是1个输入层，1个输出层，三个Block，每个Block中有1个Basicblock，每个Basicblock中有2层layer。 2、考虑到MNIST的数据集的大小为28 x 28，没经过第2个和都3个Block，大小都减半，也就是说，进入输出层时的大小为7 x 7，所以在最后用到的Average_pool的大小为7。 3、因为MNIST的channel数为1，所以in_channe
pytorch 使用AlexNet实现Mnist手写数字识别
qq_34644203的博客
03-16 6617
AlexNet网络框架如下：AlexNet的原始输入图片大小为224*224，Mnist数据集中图片大小为28*28，所以需要对网络参数进行修改。 先掉用train函数进行训练，训练好的参数会保存在params.pth文件中，训练好使用本地图片（画图软件生成）进行测试。 完整程序如下： import torch import torchvision as tv import torchvi...
PyTorch ------AlexNet卷积神经网络实现mnist手写体识别
实践是检验真理的唯一标准，经历了才会更加深切的懂得！！！
02-25 3334
接上一篇LeNet现实mnist手写识别 再次使用经典模型AlexNet实现相同的功能 先简单介绍一下,今天的主角,重燃神经网络辉煌的的模型AlexNet **AlexNet是2012年ImageNet竞赛冠军获得者Hinton和他的学生设计的,在那年之后，更多的更深的神经网络如雨后春笋般出现，比如优秀的vgg,GoogLeNet等。 对于传统的机器学习分类算法而言，已经是相当出色...
pytorch-resnet-mnist:https
05-24
PyTorch和PyTorch Lightning中MNIST的ResNet 有关详细说明/教程，请访问： :
PyTorch resnet18实现MNIST手写数字识别
m0_37990492的博客
07-01 2896
PyTorch resnet18实现MNIST手写数字识别 Warning: 这是一个学习笔记及分享向的文章， 对于初学者可能不太友好 最近突然出现了一个疑问， 用了ResNet等主流主干网络这么久， 也知道每个网络最基本的原理， 比如ResNet是利用H(x)=F(x)+x恒等变换让网络易于训练， 在有downsample的层将x进行变换匹配F(x)之后的size， 但是具体是怎么实现的呢？抱着这个疑问， 在重新阅读了ResNet这篇论文之后， 把官方源码研究了一遍。花了大概一个星期的时间， 终于把源码中
Resnet50卷积神经网络训练MNIST手写数字图像分类 Pytorch训练代码
02-05
# Resnet50卷积神经网络训练MNIST手写数字图像分类 Pytorch训练代码 1. 使用Pytorch定义ReNet50网络模型； 2. 使用Pytorch加载MNIST数据集，首次运行自动下载； 3. 实现训练MNIST手写数字图像分类，训练过程显示loss...
Python基于pytorch深度学习的车型识别系统源码+使用说明
05-23
Python基于pytorch深度学习的车型识别系统源码+使用说明 训练模型主要分为五个模块：启动器、自定义数据加载器、网络模型、学习率/损失率调整以及训练可视化。 启动器是项目的入口，通过对启动器参数的设置，可以...
tensorflow实现AlexNet训练mnist数据
05-07
tensorflow实现AlexNet训练mnist数据python代码
【TensorFlow2.0】LeNet进行手写体数字识别
桜
10-19 1193
LeNet简介 LeNet-5出自论文Gradient-Based Learning Applied to Document Recognition，是一种用于手写体字符识别的非常高效的卷积神经网络。 卷积神经网络 卷积神经网络能够很好的利用图像的结构信息。LeNet-5是一个较简单的卷积神经网络。下图显示了其结构：输入的二维图像，先经过两次卷积层到池化层，再经过全连接层，最后使用softmax分类作为输出层。下面我们主要介绍卷积层和池化层。 LeNet 1、INPUT层-输入层 2、C1层-卷积层 3、
使用PYTORCH复现ALEXNET实现MNIST手写数字识别
lwf1881的博客
11-03 5453
网络介绍： Alexnet网络是CV领域最经典的网络结构之一了，在2012年横空出世，并在当年夺下了不少比赛的冠军，下面是Alexnet的网络结构： 网络结构较为简单，共有五个卷积层和三个全连接层，原文作者在训练时使用了多卡一起训练，具体细节可以阅读原文得到。 Alexnet文章链接：http://www.cs.toronto.edu/~fritz/absps/imagenet.pdf 作者在网络中使用了Relu激活函数和Dropout等方法来防止过拟合，更多细节看文章。 数据集介绍 使用的是MNIST手
深度学习系列——AlxeNet实现MNIST手写数字体识别
AmibitionWei的博客
03-25 4248
    本文实现AlexNet,用于识别MNIST手写数字体。所有代码的框架基于tensorflow。看了几篇论文的源代码之后，觉得tensorflow 确实很难，学习编程还是靠实践。这篇博客留着给自己以及学习深度学习道路上的小伙伴们一些参考吧，希望能对大家有所帮助！    环境：    Ubuntu 16.04    tensorflow-gpu    一.数据集加载        tensor...
基于Pytorch框架的ResNet：MNIST数据集手写数字识别
qq_33629518的博客
10-22 1555
Debug经验总结 一、常规ResBlock的输出尺寸与输入尺寸相同，否则需要进行尺寸变换； 二、在数据集较大时设置num_work进行多线程处理，可以很大提高训练效率； 三、较复杂的网络在搭建前可以先用草图计算每个输出位置的矩阵尺寸，减少Debug难度； 四、选用ReLU激活函数时，应适当降低学习率，避免出现损失函数值无法下降的情况； 五、比较训练集的准确率和测试集的准确率，判断是否出现过拟合。 六、ResBlock是在激活前加入输入值作为偏移量，不能放错位置； 代码展示 import torch imp
基于LeNet实现手写体数字识别实验
最新发布
m0_70026215的博客
11-18 900
这次实验比较基础，老师也讲了毕竟LeNet是Hello world级别的深度学习模型，但是把越简单的事情要搞得越明白越透彻就越不容易，是这次使用自定义算子和框架库函数一对比，对明显体现了框架的巨大优越性。对LeNet的认识有了进一步的认知吧~正好近两天花大量时间阅览了一下深度学习入门这本书，也就是我们俗称的鱼书，这里总结一下吧~全连接神经网络存在什么问题那就是数据的形状被“忽视”了。比如，输 入数据是图像时，图像通常是高、长、通道方向上的3维形状。但是，向全 连接层输入时，需要将3维数据拉平为1维数据。
Pytorch 基于LeNet的手写数字识别
小嗷犬的博客
11-03 2298
使用MNIST数据集(Mixed National Institute of Standards and Technology database)。是美国国家标准与技术研究院收集整理的大型手写数字数据库，包含60,000个示例的训练集以及10,000个示例的测试集。本文使用 Pytorch 自动下载。LeNet是由Yann Lecun提出的一种经典的卷积神经网络，是现代卷积神经网络的起源之一。本文使用的LeNet为LeNet-5
手写体识别LeNet网络
m0_67774141的博客
10-27 127
定义Letnet网络模型，在卷积操作中使用Module提供的conv2d()函数（第一个参数代表输入灰度图数量，第二个代表输出特征图数量，第三个参数代表卷积核大小），池化操作则用max_pool12d()函数。transform函数是自定义进行数据预处理，包括将数据转化为tensor对象和进行数据归一化处理，在datasets.MNIST函数中，train='ture'代表训练集，‘false’代表测试集。训练函数，我们每运行1000次打印损失值，一共训练两次。然后就是将数据转化到GPU上运算。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值