PyTorch复现LeNet

LeNet

LeNet是一个较为简单的卷积神经网络。通过巧妙的设计,利用卷积、参数共享、池化等操作提取特征,避免了大量的计算成本,最后使用全连接神经网络进行分类识别。
LeNet网络结构示意图

创新点

现在大多数的卷积神经网络都是基于LeNet的框架(卷积层、池化层、全连接层)。

LeNet特征图变化

LeNet 使用PyTorch实现

采用PyTorch框架,使用CIFAR10训练集,训练100个epoch。

LeNet.py

class LeNet(nn.Module):
    def __init__(self):
        super(LeNet, self).__init__()
        self.conv1 = nn.Conv2d(3, 16, 5)
        self.pool1 = nn.MaxPool2d(2, 2)
        self.conv2 = nn.Conv2d(16, 32, 5)
        self.pool2 = nn.MaxPool2d(2, 2)
        self.fc1 = nn.Linear(32*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))    # input(3, 32, 32) output(16, 28, 28)
        x = self.pool1(x)            # output(16, 14, 14)
        x = F.relu(self.conv2(x))    # output(32, 10, 10)
        x = self.pool2(x)            # output(32, 5, 5)
        x = x.view(-1, 32*5*5)       # output(32*5*5)
        x = F.relu(self.fc1(x))      # output(120)
        x = F.relu(self.fc2(x))      # output(84)
        x = self.fc3(x)              # output(10)
        return x

打印LeNet模型如下
LeNet模型

relu
relu
relu
relu
input
conv1
pool1
conv2
pool2
fc1
fc2
fc3

train.py

import torch
import torchvision
import torch.nn as nn
from LeNet import LeNet

import torch.optim as optim
import torchvision.transforms as transforms


def main():
    transform = transforms.Compose(
        [
            transforms.ToTensor(),
            transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))
        ]
    )

    #50000
    #
    train_set = torchvision.datasets.CIFAR10(root='./data', train=True, download=False, transform=transform)
    train_loader = torch.utils.data.DataLoader(train_set, batch_size=36, shuffle=True, num_workers=0)

    #10000
    val_set = torchvision.datasets.CIFAR10(root='./data', train=False, download=False, transform=transform)
    val_loader = torch.utils.data.DataLoader(val_set, batch_size=5000, shuffle=False, num_workers=0)

    val_data_iter = iter(val_loader)
    val_image, val_label = val_data_iter.next()

    net = LeNet()

    loss_function = nn.CrossEntropyLoss()
    optimizer = optim.Adam(net.parameters(), lr = 0.001)

    for epoch in range(100):

        running_loss = 0.0
        for step, data in enumerate(train_loader, start=0):
            inputs, labels = data

            optimizer.zero_grad()
            outputs = net(inputs)
            loss = loss_function(outputs, labels)
            loss.backward()
            optimizer.step()

            running_loss += loss.item()
            if step % 500 == 499:
                with torch.no_grad():
                    outputs = net(val_image)
                    predict_y = torch.max(outputs, dim=1)[1]
                    accuracy = torch.eq(predict_y, val_label).sum().item() / val_label.size(0)

                    print('[%d, %5d] train_loss: %.3f test_accuracy: %.3f' %
                          (epoch + 1, step + 1, running_loss / 500, accuracy))
                    running_loss = 0.0

    print('Finished Training')

    save_path = './LeNEt.pth'
    torch.save(net.state_dict(), save_path)

if __name__ == '__main__':
    main()

predict.py

import torch
import torchvision.transforms as transforms

from PIL import Image

from LeNet import LeNet
import onnx

def main():
    transform = transforms.Compose(
        [
            transforms.Resize((32, 32)),
            transforms.ToTensor(),
            transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))
        ]
    )

    classes = ('plane', 'car', 'bird', 'cat',
               'deer', 'dog', 'frog', 'horse', 'ship', 'truck')
    net = LeNet()

    print(net)
    net.load_state_dict(torch.load('Lenet.pth'))

    im = Image.open('./1.jpg')
    im = transform(im)
    im = torch.unsqueeze(im, dim =0)

    with torch.no_grad():
        outputs = net(im)
        predict = torch.max(outputs, dim=1)[1].data.numpy()

    torch.onnx.export(net, im, "lenet.onnx")
    print(classes[int(predict)])

if __name__ == '__main__':
    main()
  • 1
    点赞
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
近年来,深度学习技术在图像识别领域得到广泛的应用。CIFAR-10是一个常用的图像数据集,由10个类别共计60,000张32×32的彩色图片组成。本文基于pytorch框架,完成了对经典的LeNet、AlexNet、VGG、GoogLeNet、MobileNet、ResNet、DenseNet等模型的复现,并进行了相应的实验和比较。 在实现过程中,我们按照经典模型论文中的网络结构和超参数,逐步搭建了各个模型,并在CIFAR-10数据集上进行训练。通过实验结果分析,我们发现在相同的训练轮数下,DenseNet具有最高的精度,其次是ResNet和VGG;MobileNet的训练速度最快,但精度稍低。AlexNet和GoogLeNet的精度和训练速度都表现较为均衡;LeNet的训练过程中出现了过拟合现象,精度相对较低。 此外,我们还对模型的计算复杂度和参数量进行了分析。在计算复杂度方面,LeNet最为简单,AlexNet到VGG的计算复杂度逐渐上升,MobileNet的计算复杂度最低,ResNet和DenseNet的计算复杂度远高于其他模型。在参数量方面,LeNet和AlexNet较为轻量,而后续的模型参数量逐渐增加,ResNet和DenseNet的参数量更是达到了数百万。 总的来说,通过本次实验,我们深入了解并复现了多种常见的图像识别模型,对各模型的特点和适用范围有了更加深入全面的认识。这将有助于我们在实际项目中选择合适的模型,并进行更加准确的预测和分析。

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值