LeNet-5应用

最新推荐文章于 2024-07-25 14:35:42 发布
最新推荐文章于 2024-07-25 14:35:42 发布
阅读量1.1k 收藏 12
点赞数 3
分类专栏： LeNet-5 文章标签： pytorch 深度学习 python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xfsong2012/article/details/128360999
版权

目录

实验1：实现MNIST手写数字识别

1、导入需要的库

2、使用GPU训练

3、图像增强

4、载入数据

5、图片可视化

 6、LeNet模型

7、加载模型并打印参数

8、损失函数，优化器

9、训练函数

10 、可视化预测结果

 实验2：将LeNet5应用在FashionMNIST上

   尝试改变参数提高精度

（1）epoch=10。

 （2）换不同的优化器

2.1 SGD优化器

实验1：实现MNIST手写数字识别

(152条消息) 用PyTorch实现MNIST手写数字识别(非常详细)_小锋学长生活大爆炸的博客-CSDN博客_mnist pytorch

1、导入需要的库

import os
import torch
import torchvision
import torch.nn as nn
from model import LeNet
import torch.optim as optim #优化算法
import torchvision.transforms as transforms
from torchsummary import summary#打印模型参数
import matplotlib.pyplot as plt
plt.rcParams['font.sans-serif']=['SimHei'] #用来正常显示中文标签
plt.rcParams['axes.unicode_minus']=False #用来正常显示负号
os.environ['KMP_DUPLICATE_LIB_OK']='True'#绘图时需要，要不然会有OMP错误

2、使用GPU训练

device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
    print("using {} device.".format(device))

3、图像增强

transform = transforms.Compose(
        [transforms.ToTensor(),#张量
         transforms.Normalize(mean=(0.5), std=(0.5))])

因为是灰度图，所以mean和std都只有一个参数，如果为RGB，都为（0.5，0.5，0.5）

4、载入数据

 train_set = torchvision.datasets.MNIST(root='./data', #存目录
                                             train=True,#训练用
                                             download=False, #下载
                                             transform=transform)#数据增强
    train_loader = torch.utils.data.DataLoader(train_set, 
                                               batch_size=32,
                                               shuffle=True, #乱序
                                               num_workers=0)#单线程

    val_set = torchvision.datasets.MNIST(root='./data', 
                                           train=False,
                                           download=False, 
                                           transform=transform)
   val_loader = torch.utils.data.DataLoader(val_set, 
                                             batch_size=10000,#将所有验证数据导入
                                             shuffle=False, 
                                             num_workers=0)
    val_data_iter = iter(val_loader)
    val_image, val_label = next(val_data_iter)

          数据导入有两步，先用datasets导入，然后用dataloader加载。如果需要下载就设置download=True即可。

5、图片可视化

显示前16个图片。

fig = plt.figure()
    for i in range(16):
        plt.subplot(4,4,i+1)
        plt.tight_layout()
        plt.imshow(val_image[i][0], cmap='gray', interpolation='none')
        plt.title("Ground Truth: {}".format(val_label[i]))
        plt.xticks([])
        plt.yticks([])
    plt.show()

 MNIST共有70000张图片，60000张训练集，10000张测试集。图片大小28*28，灰度图。

 6、LeNet模型

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,1,2)
        self.pool1 = nn.MaxPool2d(2,2)
        self.conv2 = nn.Conv2d(6,16, 5)
        self.pool2 = nn.MaxPool2d(2, 2)
        self.fc1 = nn.Linear(16*5*5, 120)
        self.fc2 = nn.Linear(120, 84)
        self.fc3 = nn.Linear(84, 10)
    #定义前向传播，输入为x
    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 = x.view(x.size()[0], -1)       
        x = F.relu(self.fc1(x))      
        x = F.relu(self.fc2(x))      
        x = self.fc3(x)              
        return x

7、加载模型并打印参数

net = LeNet()
    net.to(device)
    summary(net,input_size=(1,28,28),device="cuda")

----------------------------------------------------------------
        Layer (type)               Output Shape         Param # 
================================================================
            Conv2d-1            [-1, 6, 28, 28]             156 
         MaxPool2d-2            [-1, 6, 14, 14]               0 
            Conv2d-3           [-1, 16, 10, 10]           2,416 
         MaxPool2d-4             [-1, 16, 5, 5]               0 
            Linear-5                  [-1, 120]          48,120 
            Linear-6                   [-1, 84]          10,164 
            Linear-7                   [-1, 10]             850 
================================================================
Total params: 61,706
Trainable params: 61,706
Non-trainable params: 0
----------------------------------------------------------------
Input size (MB): 0.00
Forward/backward pass size (MB): 0.06
Params size (MB): 0.24
Estimated Total Size (MB): 0.30
----------------------------------------------------------------

8、损失函数，优化器

#损失函数
    loss_function = nn.CrossEntropyLoss()
    #优化器
    optimizer = optim.Adam(net.parameters(), lr=0.001)

9、训练函数

    tr_loss=[]
    val_acc=[]
    #开始训练
    for epoch in range(5):  # loop over the dataset multiple times

        running_loss = 0.0
        for step, data in enumerate(train_loader, start=0):
            # get the inputs; data is a list of [inputs, labels]
            inputs, labels = data

            # zero the parameter gradients
            optimizer.zero_grad() #梯度清零
            # forward + backward + optimize
            outputs = net(inputs.to(device))
            loss = loss_function(outputs, labels.to(device))
            loss.backward()
            optimizer.step()

            # print statistics
            running_loss += loss.item()
            if step % 500 == 499:    # print every 500 mini-batches
                with torch.no_grad():
                    outputs = net(val_image.to(device))  # [batch, 10]
                    predict_y = torch.max(outputs, dim=1)[1]
                    accuracy = torch.eq(predict_y, val_label.to(device)).sum().item() / val_label.size(0)
                    tr_loss.append(running_loss / 500)
                    val_acc.append(accuracy)
                    print('[%d, %5d] train_loss: %.3f  acc:%d/%d %.0f%%' %
                          (epoch + 1, step + 1, running_loss / 500,torch.eq(predict_y, val_label.to(device)).sum().item(),val_label.size(0),100.*accuracy))
                    running_loss = 0.0

    print('Finished Training')
    plt.plot(tr_loss,label='loss')
    plt.plot(val_acc,label='accuracy')
    plt.legend()
    plt.show()

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

[1,   500] train_loss: 0.443  acc:9659/10000 97%
[1,  1000] train_loss: 0.127  acc:9765/10000 98%
[1,  1500] train_loss: 0.085  acc:9767/10000 98%
[2,   500] train_loss: 0.065  acc:9773/10000 98%
[2,  1000] train_loss: 0.059  acc:9812/10000 98%
[2,  1500] train_loss: 0.059  acc:9757/10000 98%
[3,   500] train_loss: 0.049  acc:9853/10000 99%
[3,  1000] train_loss: 0.042  acc:9859/10000 99%
[3,  1500] train_loss: 0.044  acc:9868/10000 99%
[4,   500] train_loss: 0.036  acc:9878/10000 99%
[4,  1000] train_loss: 0.035  acc:9821/10000 98%
[4,  1500] train_loss: 0.035  acc:9872/10000 99%
[5,   500] train_loss: 0.024  acc:9908/10000 99%
[5,  1000] train_loss: 0.028  acc:9871/10000 99%
[5,  1500] train_loss: 0.028  acc:9865/10000 99%
Finished Training

 预测结果epoch=3的时候已经成绩达到99%。

10 、可视化预测结果

examples = enumerate(val_loader)
    batch_idx, (example_data, example_targets) = next(examples)
    with torch.no_grad():
        output = net(example_data.to(device))
    fig = plt.figure()
    for i in range(16):
        plt.subplot(4,4,i+1)
        plt.tight_layout()
        plt.imshow(example_data[i][0], cmap='gray', interpolation='none')
        plt.title("Prediction: {}".format(output.data.max(1, keepdim=True)[1][i].item()))
        plt.xticks([])
        plt.yticks([])
    plt.show()

 全部预测成功。 LeNet在MNIST上的效果很好。

完整的程序：

##################################################
#导入需要的库
##################################################
import os
import torch
import torchvision
import torch.nn as nn
from model import LeNet
import torch.optim as optim #优化算法
import torchvision.transforms as transforms
from torchsummary import summary#打印模型参数
import matplotlib.pyplot as plt
plt.rcParams['font.sans-serif']=['SimHei'] #用来正常显示中文标签
plt.rcParams['axes.unicode_minus']=False #用来正常显示负号
os.environ['KMP_DUPLICATE_LIB_OK']='True'#绘图时需要，要不然会有OMP错误

def main():
    #使用GPU
    device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
    print("using {} device.".format(device))
##################################################
#图像增强
#如果是灰度图,设置transforms.Normalize（（0.5），（0.5））即可。
# RGB图，需要改为transforms.Normalize（（0.5，0.5，0.5），（0.5，0.5，0.5））
##################################################
    transform = transforms.Compose(
        [transforms.ToTensor(),#张量
         transforms.Normalize(mean=(0.5), std=(0.5))])#归一化，std=0.5,mean=0.5
##################################################
#加载训练数据集
# 50000张训练图片
# 第一次使用时要将download设置为True才会自动去下载数据集
##################################################
    train_set = torchvision.datasets.MNIST(root='./data', #存目录
                                             train=True,#训练用
                                             download=True, #下载
                                             transform=transform)#数据增强
    train_loader = torch.utils.data.DataLoader(train_set, 
                                               batch_size=32,
                                               shuffle=True, #乱序
                                               num_workers=0)#单线程
##################################################
#加载验证集
# 10000张验证图片
# 第一次使用时要将download设置为True才会自动去下载数据集
##################################################
    val_set = torchvision.datasets.MNIST(root='./data', 
                                           train=False,
                                           download=True, 
                                           transform=transform)
    val_loader = torch.utils.data.DataLoader(val_set, 
                                             batch_size=10000,#将所有验证数据导入
                                             shuffle=False, 
                                             num_workers=0)
    val_data_iter = iter(val_loader)
    val_image, val_label = next(val_data_iter)
       ########################################################
    #显示前4个验证集图片
    ########################################################
    fig = plt.figure()
    for i in range(16):
        plt.subplot(4,4,i+1)
        plt.tight_layout()
        plt.imshow(val_image[i][0], cmap='gray', interpolation='none')
        plt.title("Ground Truth: {}".format(val_label[i]))
        plt.xticks([])
        plt.yticks([])
    plt.show()
    
    #加载模型
    net = LeNet()
    net.to(device)
    summary(net,input_size=(1,28,28),device="cuda")
    #损失函数
    loss_function = nn.CrossEntropyLoss()
    #优化器
    optimizer = optim.Adam(net.parameters(), lr=0.001)
    tr_loss=[]
    val_acc=[]
    #开始训练
    for epoch in range(5):  # loop over the dataset multiple times

        running_loss = 0.0
        for step, data in enumerate(train_loader, start=0):
            # get the inputs; data is a list of [inputs, labels]
            inputs, labels = data

            # zero the parameter gradients
            optimizer.zero_grad() #梯度清零
            # forward + backward + optimize
            outputs = net(inputs.to(device))
            loss = loss_function(outputs, labels.to(device))
            loss.backward()
            optimizer.step()

            # print statistics
            running_loss += loss.item()
            if step % 500 == 499:    # print every 500 mini-batches
                with torch.no_grad():
                    outputs = net(val_image.to(device))  # [batch, 10]
                    predict_y = torch.max(outputs, dim=1)[1]
                    accuracy = torch.eq(predict_y, val_label.to(device)).sum().item() / val_label.size(0)
                    tr_loss.append(running_loss / 500)
                    val_acc.append(accuracy)
                    print('[%d, %5d] train_loss: %.3f  acc:%d/%d %.0f%%' %
                          (epoch + 1, step + 1, running_loss / 500,torch.eq(predict_y, val_label.to(device)).sum().item(),val_label.size(0),100.*accuracy))
                    running_loss = 0.0
    examples = enumerate(val_loader)
    batch_idx, (example_data, example_targets) = next(examples)
    with torch.no_grad():
        output = net(example_data.to(device))
    fig = plt.figure()
    for i in range(16):
        plt.subplot(4,4,i+1)
        plt.tight_layout()
        plt.imshow(example_data[i][0], cmap='gray', interpolation='none')
        plt.title("Prediction: {}".format(output.data.max(1, keepdim=True)[1][i].item()))
        plt.xticks([])
        plt.yticks([])
    plt.show()
    print('Finished Training')
    fig1=plt.figure()
    plt.plot(tr_loss,label='loss')
    plt.plot(val_acc,label='accuracy')
    plt.legend()
    plt.show()

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

if __name__ == '__main__':
    main()

 实验2：将LeNet5应用在FashionMNIST上

FashionMNIST数据集的介绍：(152条消息) Fashion MNIST数据集介绍及下载_Dick-andy的博客-CSDN博客_“fashion-mnist”数据集下载

大小和MNIST一样。只是把数字0-9换成了衣物。

 修改的地方：

1、数据加载

train_set = torchvision.datasets.FashionMNIST(root='./data', #存目录
                                             train=True,#训练用
                                             download=True, #下载
                                             transform=transform)#数据增强

val_set = torchvision.datasets.FashionMNIST(root='./data', 
                                           train=False,
                                           download=True, 
                                           transform=transform)

可视化显示16个图片。

  其它都不需要修改，直接可以进行训练。

[1,   500] train_loss: 0.774  acc:7761/10000 78%
[1,  1000] train_loss: 0.499  acc:8063/10000 81%
[1,  1500] train_loss: 0.434  acc:8410/10000 84%
[2,   500] train_loss: 0.371  acc:8617/10000 86%
[2,  1000] train_loss: 0.343  acc:8739/10000 87%
[2,  1500] train_loss: 0.326  acc:8749/10000 87%
[3,   500] train_loss: 0.309  acc:8774/10000 88%
[3,  1000] train_loss: 0.309  acc:8872/10000 89%
[3,  1500] train_loss: 0.283  acc:8846/10000 88%
[4,   500] train_loss: 0.276  acc:8882/10000 89%
[4,  1000] train_loss: 0.269  acc:8943/10000 89%
[4,  1500] train_loss: 0.262  acc:8888/10000 89%
[5,   500] train_loss: 0.253  acc:8930/10000 89%
[5,  1000] train_loss: 0.236  acc:8983/10000 90%
[5,  1500] train_loss: 0.248  acc:8966/10000 90%
Finished Training

训练结果在epoch=5时，能达到91%。可视化预测结果，可以看出，16个预测14个准确，准确率87.5%。

        

   尝试改变参数提高精度

（1）epoch=10。

[1,   500] train_loss: 0.779  acc:7839/10000 78%
[1,  1000] train_loss: 0.508  acc:8168/10000 82%
[1,  1500] train_loss: 0.428  acc:8383/10000 84%
[2,   500] train_loss: 0.373  acc:8564/10000 86%
[2,  1000] train_loss: 0.361  acc:8621/10000 86%
[2,  1500] train_loss: 0.349  acc:8659/10000 87%
[3,   500] train_loss: 0.305  acc:8714/10000 87%
[3,  1000] train_loss: 0.306  acc:8760/10000 88%
[3,  1500] train_loss: 0.305  acc:8860/10000 89%
[4,   500] train_loss: 0.281  acc:8892/10000 89%
[4,  1000] train_loss: 0.270  acc:8801/10000 88%
[4,  1500] train_loss: 0.279  acc:8841/10000 88%
[5,   500] train_loss: 0.246  acc:8871/10000 89%
[5,  1000] train_loss: 0.251  acc:8907/10000 89%
[5,  1500] train_loss: 0.253  acc:8895/10000 89%
[6,   500] train_loss: 0.232  acc:8934/10000 89%
[6,  1000] train_loss: 0.236  acc:8944/10000 89%
[6,  1500] train_loss: 0.243  acc:8952/10000 90%
[7,   500] train_loss: 0.214  acc:8962/10000 90%
[7,  1000] train_loss: 0.221  acc:8965/10000 90%
[7,  1500] train_loss: 0.227  acc:9020/10000 90%
[8,   500] train_loss: 0.198  acc:8993/10000 90%
[8,  1000] train_loss: 0.206  acc:9022/10000 90%
[8,  1500] train_loss: 0.219  acc:8912/10000 89%
[9,   500] train_loss: 0.190  acc:8908/10000 89%
[9,  1000] train_loss: 0.198  acc:8982/10000 90%
[9,  1500] train_loss: 0.190  acc:8979/10000 90%
[10,   500] train_loss: 0.178  acc:8966/10000 90%
[10,  1000] train_loss: 0.184  acc:9026/10000 90%
[10,  1500] train_loss: 0.186  acc:9043/10000 90%
Finished Training

能达到90%精度。预测图100%正确。所以提高epoch还是有用的。

 （2）换不同的优化器

2.1 SGD优化器

optimizer = optim.SGD(net.parameters(),lr=0.001,momentum=0.5)

[1,   500] train_loss: 2.292  acc:1722/10000 17%
[1,  1000] train_loss: 2.255  acc:3446/10000 34%
[1,  1500] train_loss: 2.010  acc:3746/10000 37%
[2,   500] train_loss: 0.990  acc:6620/10000 66%
[2,  1000] train_loss: 0.849  acc:6817/10000 68%
[2,  1500] train_loss: 0.794  acc:7136/10000 71%
[3,   500] train_loss: 0.727  acc:7248/10000 72%
[3,  1000] train_loss: 0.714  acc:7303/10000 73%
[3,  1500] train_loss: 0.693  acc:7329/10000 73%
[4,   500] train_loss: 0.664  acc:7398/10000 74%
[4,  1000] train_loss: 0.659  acc:7560/10000 76%
[4,  1500] train_loss: 0.634  acc:7469/10000 75%
[5,   500] train_loss: 0.627  acc:7608/10000 76%
[5,  1000] train_loss: 0.612  acc:7593/10000 76%
[5,  1500] train_loss: 0.595  acc:7665/10000 77%
[6,   500] train_loss: 0.584  acc:7771/10000 78%
[6,  1000] train_loss: 0.582  acc:7712/10000 77%
[6,  1500] train_loss: 0.566  acc:7746/10000 77%
[7,   500] train_loss: 0.556  acc:7802/10000 78%
[7,  1000] train_loss: 0.551  acc:7895/10000 79%
[7,  1500] train_loss: 0.545  acc:7887/10000 79%
[8,   500] train_loss: 0.531  acc:8042/10000 80%
[8,  1000] train_loss: 0.518  acc:8029/10000 80%
[8,  1500] train_loss: 0.525  acc:7823/10000 78%
[9,   500] train_loss: 0.506  acc:8093/10000 81%
[9,  1000] train_loss: 0.503  acc:8084/10000 81%
[9,  1500] train_loss: 0.508  acc:7940/10000 79%
[10,   500] train_loss: 0.484  acc:8078/10000 81%
[10,  1000] train_loss: 0.481  acc:8153/10000 82%
[10,  1500] train_loss: 0.487  acc:8236/10000 82%

准确性只有80%。性能不升反而降低了。

我闻 如是
关注
  • 3
    点赞
  • 踩
  • 12
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
传统CNN的概念理解--LeNet-5
qq_33328642的博客
08-29 637
CNN结构可视化的神器 没错，看到这个网站了吗。有了这个网站，我们可以把CNN的结构很好的可视化。 基本上可以解释你对CNN的 feather map和卷积核filter的所有疑惑。 https://www.cs.ryerson.ca/~aharley/vis/conv/ 不多说了，上面就是这个可视化工具的网址。这个可视化工具的CNN框架是LeNet-5。 来，我们看一下LeNet-5的网络结构。正好啊，这个网络的输入是单通道灰度图为例的。 2 CNN的一些专用名词 feature map、卷积核、
基于LeNet5实现手写数字识别，可视化卷积层。
2303_79620604的博客
05-14 982
本文章将基于LeNet5实现手写数字识别，并增加卷积层，探索卷积层多与少的区别，通过可视化卷积层，是大家更理解CNN这个抽象的概念！
LeNet-5算法入门
牛肉胡辣汤
10-26 175
LeNet-5是一个经典的卷积神经网络（CNN）算法，由Yann LeCun等人于1998年提出。它是第一个成功应用于手写数字识别的卷积神经网络，将深度学习引入到了计算机视觉领域。LeNet-5算法由七个网络层组成，其中包含了卷积层、池化层和全连接层，以及非线性激活函数等。LeNet-5算法是一个经典的卷积神经网络算法，被广泛用于手写数字识别等计算机视觉任务。它的网络结构相对简单，但在MNIST数据集等任务上可以达到较高的准确率。这个算法的实现可以帮助初学者理解和入门卷积神经网络的基本概念和原理。
经典网络-LeNet-5
春秋繁露
06-20 583
在下面的篇幅中将详细介绍LeNet-5 模型每一层的结构。③ 第一层，卷积层 这一层的输入就是原始的图像像素，LeNet-5 模型接受的输入层大小为32×32×1。第一 个卷积层过滤器的尺寸为5×5，深度为6，不使用全0 填充，步长为1。因为没有使用全0 填充，所以这一层的输出的尺寸为32−5+1=28，深度为6。这一个卷积层总共有 5×5×1×6+6=156 个参数，其中6 个为偏置项参数。因为下一层的节点矩阵有28×28×6=4704 个节点， 每个节点和5×5=25 个当前层节点相连， 所以本层卷积.
LeNet-5经典卷积神经网络模型搭建及应用实例
dooglocool的博客
12-29 810
LeNet-5卷积神经网络是用于图像识别的经典神经网络，本文从零复现整个模型，同时采用相应的数据集进行训练和测试。
深度学习10. CNN经典网络 LeNet-5实现MNIST
编程圈子-谢厂节的博客
03-16 1150
LeNet-5是一个经典的卷积神经网络模型，1998年被提出，论文题目是 “Gradient-Based Learning Applied to Document Recognition” ，作者为 Yann LeCun, Léon Bottou, Yoshua Bengio, and Patrick Haffner。LeNet-5是一个用于手写数字识别的深度神经网络模型，由两个卷积层和三个全连接层组成。LeNet-5是深度神经网络的开创者之一，对后来的深度学习算法发展产生了重要的影响。
LeNet-5实战
风间琉璃的博客
02-11 1436
一、LeNet-5介绍 LeNet-5用于手写数字和机器打印字符图片识别的神经网络。 LeNet-5 的网络结构图，它接受32 × 32大小的数字、字符图片，经过第一个卷积层得到[b, 28,28,6] 形状的张量，经过一个向下采样层，张量尺寸缩小到[b,14,14,6] ，经过第二个卷积层，得到[b,10,10,16] 形状的张量，同样经过下采样层，张量尺寸缩小到[b,5,5,16]]，在进入全连接层之前，先将张量打成[b,400]的张量，送入输出节点数分别为 120、 84 的 2 个全连接层，
LeNet-5 数字图像识别
chang_jx的博客
08-10 206
本文介绍了经典网络LeNet-5的结构以及运用网络进行手写数字识别的代码实现
卷积神经网络：LeNet-5
热门推荐
weixin_45873017的博客
12-14 1万+
2021SC@SDUSC LeNet-5卷积神经网络的整体框架： 特征映射：一幅图在经过卷积操作后得到结果称为特征图。 LeNet-5共有8层，包含输入层，每层都包含可训练参数；每个层有多个特征映射(，每个特征映射通过一种卷积核（或者叫滤波器）提取输入的一种特征，然后每个特征映射有多个神经元。C层代表的是卷积层，通过卷积操作，可以使原信号特征增强，并且降低噪音。 S层是一个降采样层，利用图像局部相关性的原理，对图像进行子抽样，可以减少数据处理量同时保留有用信息。 计算公式：输入图像的大小为nxn，卷积核的
基于Lenet-5预测股票走势
AtYeXTolearn的博客
08-18 251
Lenet-5是基于对图片的二维卷积，图片本质上是二维数据(黑白)和三维数据(彩色)，需要构建二维数据。其中以窗口滑动的方式，将open、high、low构成特征集，以窗口大小里出现label次数最多的数字作为标签集
LeNet-5，卷积神经网络模型
06-05
LeNet-5手写字识别实验：LeNet-5是一个经典的卷积神经网络模型，由Yann LeCun等人于1998年提出。它是首个广泛应用于手写数字识别任务的卷积神经网络模型，并在该任务上取得了很好的性能。LeNet-5模型使用了sigmoid...
LeNet-5.rar_LeNet-5模型_LeNet模型 PPT_lenet_lenet识别_神经网络
07-15
在本资料包中，我们重点探讨LeNet-5模型的结构、工作原理以及其在MNIST数据集上的应用。 **一、LeNet-5结构** LeNet-5模型主要由以下几个部分组成： 1. **输入层（Input Layer）**：接收28x28像素的手写数字图像...
LeNet-5-with-Keras:LeNet-5与keras的实现
05-01
**LeNet-5模型概述** LeNet-5是由Yann LeCun在1998年提出的一种卷积神经网络（CNN），它是最早的用于手写数字识别的深度学习模型之一。该模型的成功在于它能够自动从输入图像中提取特征，为后来的深度学习研究和...
C语言实现神经网络手写数字识别_LeNet-5
07-02
LeNet-5是Yann LeCun在1998年提出的一个经典卷积神经网络（Convolutional Neural Network，CNN）架构，主要用于手写数字识别，尤其在OCR（光学字符识别）技术中取得了显著成效。本项目使用C语言来实现LeNet-5，这在...
lenet-5模型的手写数字识别
04-17
LeNet-5是由Yann LeCun等人在1998年提出的一种卷积神经网络（Convolutional Neural Network, CNN），它在当时被广泛应用于OCR（Optical Character Recognition）系统，特别是对手写数字的识别。 LeNet-5模型的核心...
N3 - Pytorch文本分类入门
最新发布
Loser
07-25 873
文本分类任务，关键的是前面对文本的处理，合并，嵌入，最后的分类反而非常简直，直接使用了一层全连接层就可以达到不错的效果了。在复现的过程中，由于使用的库版本不一致导致torchtext库部分代码无法正常运行，卡了好久，后面搜索了一些之前打卡的同学的博客，才找到解决方案。复现模型时尽量不要使用最新的版本，而是使用原来的版本，先运行起来，再改动。
【Pytorch实战教程】Pytorch中model.train()和model.eval()的作用
惊鸿若梦一书生
07-22 284
在 PyTorch 中，`model.train()` 和 `model.eval()` 用于设置模型的`训练模式`和`评估模式`，它们的作用主要涉及模型中的特定层如批归一化（Batch Normalization）和丢弃（Dropout）等。
Pytorch笔记（1-5）
2301_81989837的博客
07-20 381
张量可以理解为numpy里面的矩阵，可以进行矩阵的操作。
LeNet-5 PyTorch实战：经典CNN结构与应用详解
文章首先介绍了LeNet-5的背景，它是第一个使用反向传播（BP）算法训练的CNN模型，标志着深度学习在视觉任务中的应用正式起步。 LeNet-5的特点包括其简单但关键的网络结构，它包含卷积层、池化层和全连接层，这些是...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值