day09-----pytorch两种编程方式实现手写数字LeNet-5

最新推荐文章于 2023-01-17 16:41:34 发布
最新推荐文章于 2023-01-17 16:41:34 发布
阅读量246 收藏 1
点赞数
分类专栏： 项目实训
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_34405401/article/details/104708460
版权

文章目录

所需数据

在 day10 数据里

1.两种方式手工实现 LeNet-5

LetNe-5t是一种入门级的神经网络模型，是一个简单的卷积神经网络，可以用来做手写体识别

2.不使用框架实现

import struct
import numpy as np
import torch
import math

# 加载图像
def load_image_fromfile(filename):
    # 打开文件
    with open(filename, 'rb') as fd:
        # 循环读取
        header_buf = fd.read(16)
        # 解析数据
        magic_, nums_, w_, h_ = struct.unpack('>iiii', header_buf) 
        # 保存成ndarray
        imgs_ = np.fromfile(fd, dtype=np.uint8)
        imgs_ = imgs_.reshape(nums_, h_, w_)
    return imgs_
def load_label_fromfile(filename):
    # 打开文件
    with open(filename, 'rb') as fd:
        # 循环读取
        header_buf = fd.read(8)
        # 解析数据
        magic_, nums_ = struct.unpack('>ii', header_buf) 
        # 保存成ndarray
        labels_ = np.fromfile(fd, dtype=np.uint8)
    return labels_

卷积神经网络的各层的意义：https://www.cnblogs.com/wj-1314/p/9593364.html

下面的图中：

卷积核解释：卷积运算后，图像会缩小卷积核-1，即卷积核等于5，则少两圈即4像素

1.第一张图（实际读取的是2828，与下图的3232不符，所以代码中第一层都有padding=2，扩充到32）到6@28*28需要一个卷积层，卷积核是5，因为计算是32-x+1=28,因此x是28；

2.6@2828到6@1414是降维，用池化函数降维即可，不需要构建层

3.6@1414到16@1010需要卷积层，卷积核=14-10+1=5

4.16@1010到16@55是降维，用池化函数降维即可

5.16@5*5到120@ 1 * 1是卷积层，卷积核同样是5

6.120@1 * 1到84@1 * 1全连接层（线性层）：先把120 1 * 1变成一维向量再变成84个向量

7.84@1 * 1到10@1 * 1全连接层（线性层）：变成10个向量

8.在十个向量中挑最大的那个的角标作为他的类

在这里插入图片描述

  • 输入图像：INPUT：N*32*32*1
    • N是图像数量
    • 1是图像深度
    • 32*32是图像高宽（有的数据集图像高宽是28*28,这个可以在卷积运算的时候，指定Padding即可）
  • 池化层：C1：6@28*28 -> 6@14*14
    • 采用2*2的最大池化可以降维一半。
  • 从卷积层（图像特征学习层）到全连接层（分类层）：C5: 120@1*1
    • 这一层在上图中表示不清楚，需要特别注意，因为这儿有一个数据格式转换的问题（在Torch中就是view的问题）

数据准备：

#读取训练集
train_x = load_image_fromfile("datasets/train-images.idx3-ubyte")
train_y = load_label_fromfile("datasets/train-labels.idx1-ubyte")
train_x = train_x.astype(np.float64)
train_y = train_y.astype(np.int64)
#读取测试集
test_x = load_image_fromfile("datasets/t10k-images.idx3-ubyte")
test_y = load_label_fromfile("datasets/t10k-labels.idx1-ubyte")

# #处理数据
# x=torch.from_numpy(train_x.reshape(-1,1,28,28)).float()
# y=torch.from_numpy(train_y.astype(int))

# t_x=torch.from_numpy(test_x.reshape(-1,1,28,28)).float()
# t_y=torch.from_numpy(test_y.astype(int))

#LongTensor是CPU tensor中64位有符号整型，在数据处理中使用长整型会保险点
x = torch.Tensor(train_x).view(train_x.shape[0], 1, train_x.shape[1], train_x.shape[2])   # N,C,W,H
y = torch.LongTensor(train_y)
# # 测试集
t_x =  torch.Tensor(test_x).view(test_x.shape[0], 1, test_x.shape[1], test_x.shape[2])   # N,C,W,H
t_y =  torch.LongTensor(test_y)

参数准备：

#可训练参数
#保证数据不能爆的处理方法/初始化：
w_6_5_5=torch.Tensor(6,1,5,5) #构造6个模板，模板深度为1（即 1 通道图像），每个模板是5*5
b_6_5_5 = torch.Tensor(6)  
stdv=1.0/math.sqrt(1*5*5)
w_6_5_5.data.uniform_(-stdv,stdv)
b_6_5_5.data.uniform_(-stdv, stdv)

w_6_5_5.requires_grad=True
b_6_5_5.requires_grad = True

w_16_5_5=torch.Tensor(16,6,5,5) #由6个模板转换，因此深度是6
b_16_5_5 = torch.Tensor(16)
stdv=1.0/math.sqrt(6*5*5)
w_16_5_5.data.uniform_(-stdv,stdv)
b_16_5_5.data.uniform_(-stdv, stdv)
#w_16_5_5 = torch.randn(16,6,5,5) #由6个模板转换，因此深度是6
w_16_5_5.requires_grad=True
b_16_5_5.requires_grad = True

w_120_5_5=torch.Tensor(120,16,5,5)
b_120_5_5 = torch.Tensor(120) 
stdv=1.0/math.sqrt(16*5*5)
w_120_5_5.data.uniform_(-stdv,stdv)
#w_120_5_5 = torch.randn(120,16,5,5) #由16个转换，因此深度是1
b_120_5_5.data.uniform_(-stdv, stdv)
w_120_5_5.requires_grad=True
b_120_5_5.requires_grad = True

#图像转换为向量
w_120_to_84 = torch.Tensor(84, 120) 
b_120_to_84 = torch.Tensor(84) 
# 初始化
stdv = 1.0 / math.sqrt(120)   # 使用输入的特征数作为均匀分布的计算基数
w_120_to_84.data.uniform_(-stdv, stdv)
b_120_to_84.data.uniform_(-stdv, stdv)
w_120_to_84.requires_grad=True
b_120_to_84.requires_grad=True

w_84_to_10=torch.Tensor(10, 84) 
b_84_to_10=torch.Tensor(10)
# 初始化
stdv = 1.0 / math.sqrt(84)
w_84_to_10.data.uniform_(-stdv, stdv)
b_84_to_10.data.uniform_(-stdv, stdv)
b_84_to_10.requires_grad=True
w_84_to_10.requires_grad=True #最终预测的类是分量概率最大的下标

#超参数
rate=0.001
epoch=20 #训练次数
batch_size=1000 #每批训练1000个
batch_num=len(train_y)//batch_size

决策模型：

#决策模型封装成函数
def res(input):
    """
    input的格式：4-D（N, 1, 28, 28）：N表示每批次的样本数量
    out的格式：与input相同4-D（N, 10）：N表示每批次的样本数量
    """
    # 1.1 
    o_c1 = torch.nn.functional.conv2d(input=input, weight=w_6_5_5, bias=b_6_5_5, padding = 2)  # 原始图像28*28
    o_a1 = torch.nn.functional.relu(o_c1)
    o_p1 = torch.nn.functional.max_pool2d(input= o_a1, kernel_size=(2,2))#池化降维
    o1 = o_p1
    # 1.2
    o_c2 = torch.nn.functional.conv2d(input=o1, weight=w_16_5_5, bias=b_16_5_5)
    o_a2 = torch.nn.functional.relu(o_c2)
    o_p2 = torch.nn.functional.max_pool2d(input= o_a2, kernel_size=(2,2))#池化降维
    o2 = o_p2
    # 1.3
    o_c3 = torch.nn.functional.conv2d(input=o2, weight=w_120_5_5, bias=b_120_5_5)
    o_a3 = torch.nn.functional.relu(o_c3)
    # 无池化
    # o3 = o_a3.squeeze()    # 格式转换(把最后的1*1直接降维掉），转换为60000 * 120
    o3 = o_a3.view(o_a3.shape[0], o_a3.shape[1])
    # 1.4
    o_c4 = torch.nn.functional.linear(o3, w_120_to_84, b_120_to_84)
    o_a4 = torch.nn.functional.relu(o_c4)
    o4 = o_a4
    # 1.5
    o_c5 = torch.nn.functional.linear(o4, w_84_to_10, b_84_to_10)
    o_a5 = torch.log_softmax(o_c5, dim=1)
    o5 = o_a5
    return  o5

定义损失函数：

#定义损失函数
def loss_function(out,target):
    loss=torch.nn.functional.cross_entropy(out,target) #这个损失函数已经带了sigmoid
    return loss

迭代训练：

for n in range(epoch):
    for index in range(batch_num):
        #决策函数计算
        start=index*batch_size
        end=(index+1)*batch_size
        b_x = x[start: end]
        b_y = y[start: end]
        b_y_=res(b_x)
        #计算损失
        loss=loss_function(b_y_,b_y)
        #求梯度
        loss.backward(retain_graph=True)

        #关闭graph跟踪环境
        with torch.autograd.no_grad():
            #更新权重
            w_6_5_5 -= rate*w_6_5_5.grad
            b_6_5_5 -= rate * b_6_5_5.grad
            w_16_5_5 -= rate*w_16_5_5.grad
            b_16_5_5 -= rate * b_16_5_5.grad
            w_120_5_5 -= rate*w_120_5_5.grad
            b_120_5_5 -= rate * b_120_5_5.grad
            
            w_120_to_84 -= rate*w_120_to_84.grad
            b_120_to_84 -= rate*b_120_to_84.grad

            w_84_to_10 -= rate*w_84_to_10.grad
            b_84_to_10 -= rate*b_84_to_10.grad

            #置0
            w_6_5_5.grad.zero_()
            b_6_5_5.grad.zero_()
            w_16_5_5.grad.zero_()
            b_16_5_5.grad.zero_()
            w_120_5_5.grad.zero_()
            b_120_5_5.grad.zero_()
            w_120_to_84.grad.zero_()
            b_120_to_84.grad.zero_()
            w_84_to_10.grad.zero_()
            b_84_to_10.grad.zero_()


    #if n % 10 ==0:
    print(F"第{n}轮")
    print(F"\t损失值：{loss:8.6f}",end="")  
    #测试，为了防止测试的forward被跟踪
    with torch.autograd.no_grad():
        predict=res(t_x)
        #找出每个样本输出长度为10的向量中的最大向量的角标
        t_y_=predict.argmax(dim=1)
        #判别是否预测正确
        correct_rate=(t_y_ == t_y).float().mean()
        print(F"\t测试集准确率：{correct_rate*100: 6.2f}%")
print("------训练完毕------")

第0轮
	损失值：0.735620	测试集准确率： 78.79%
第1轮
	损失值：0.400198	测试集准确率： 87.28%
第2轮
	损失值：0.297932	测试集准确率： 90.00%
第3轮
	损失值：0.248001	测试集准确率： 91.27%
第4轮
	损失值：0.218103	测试集准确率： 92.05%
第5轮
	损失值：0.197649	测试集准确率： 92.59%
第6轮
	损失值：0.183804	测试集准确率： 93.13%
第7轮
	损失值：0.173268	测试集准确率： 93.44%
第8轮
	损失值：0.164415	测试集准确率： 93.77%
第9轮
	损失值：0.157504	测试集准确率： 94.06%
第10轮
	损失值：0.151838	测试集准确率： 94.38%
第11轮
	损失值：0.147313	测试集准确率： 94.64%
第12轮
	损失值：0.142812	测试集准确率： 94.90%
第13轮
	损失值：0.138839	测试集准确率： 95.05%
第14轮
	损失值：0.135344	测试集准确率： 95.24%
第15轮
	损失值：0.131895	测试集准确率： 95.45%
第16轮
	损失值：0.129000	测试集准确率： 95.59%
第17轮
	损失值：0.126409	测试集准确率： 95.74%
第18轮
	损失值：0.124006	测试集准确率： 95.87%
第19轮
	损失值：0.121591	测试集准确率： 95.96%
------训练完毕------

数据爆掉引起的失误解决办法:

  1. 数据集规范化
  2. 控制权重初始值
  3. 输出的时候用激活函数控制

优化:

1.在卷积运算添加一个偏置项，对图像的灰度有脱敏效果

3.框架实现（构建卷积神经网络）

卷积神经网络的各层的意义：https://www.cnblogs.com/wj-1314/p/9593364.html

下面的图中：

卷积核解释：卷积运算后，图像会缩小卷积核-1，即卷积核等于5，则少两圈即4像素

1.第一张图（实际读取的是2828，与下图的3232不符，所以代码中第一层都有padding=2，扩充到32）到6@28*28需要一个卷积层，卷积核是5，因为计算是32-x+1=28,因此x是28；

2.6@2828到6@1414是降维，用池化函数降维即可，不需要构建层

3.6@1414到16@1010需要卷积层，卷积核=14-10+1=5

4.16@1010到16@55是降维，用池化函数降维即可

5.16@5*5到120@ 1 * 1是卷积层，卷积核同样是5

6.120@1 * 1到84@1 * 1全连接层（线性层）：先把120 1 * 1变成一维向量再变成84个向量

7.84@1 * 1到10@1 * 1全连接层（线性层）：变成10个向量

8.在十个向量中挑最大的那个的角标作为他的类

在这里插入图片描述

import struct
import numpy as np
import torch
import torch.utils.data
 
# 加载图像
def load_image_fromfile(filename):
    # 打开文件
    with open(filename, 'rb') as fd:
        # 循环读取
        header_buf = fd.read(16)
        # 解析数据
        magic_, nums_, w_, h_ = struct.unpack('>iiii', header_buf) 
        # 保存成ndarray
        imgs_ = np.fromfile(fd, dtype=np.uint8)
        imgs_ = imgs_.reshape(nums_, h_, w_)
    return imgs_
def load_label_fromfile(filename):
    # 打开文件
    with open(filename, 'rb') as fd:
        # 循环读取
        header_buf = fd.read(8)
        # 解析数据
        magic_, nums_ = struct.unpack('>ii', header_buf) 
        # 保存成ndarray
        labels_ = np.fromfile(fd, dtype=np.uint8)
    return labels_

数据准备：

#读取训练集
train_x = load_image_fromfile("datasets/train-images.idx3-ubyte")
train_y = load_label_fromfile("datasets/train-labels.idx1-ubyte")
train_x = train_x.astype(np.float64)
train_y = train_y.astype(np.int64)
#读取测试集
test_x = load_image_fromfile("datasets/t10k-images.idx3-ubyte")
test_y = load_label_fromfile("datasets/t10k-labels.idx1-ubyte")


#LongTensor是CPU tensor中64位有符号整型，在数据处理中使用长整型会保险点
x = torch.Tensor(train_x).view(train_x.shape[0], 1, train_x.shape[1], train_x.shape[2])   # N,C,W,H
y = torch.LongTensor(train_y)
# # 测试集
t_x =  torch.Tensor(test_x).view(test_x.shape[0], 1, test_x.shape[1], test_x.shape[2])   # N,C,W,H
t_y =  torch.LongTensor(test_y)

数据集使用TensorDataset管理

train_dataset=torch.utils.data.TensorDataset(x,y)
test_dataset=torch.utils.data.TensorDataset(t_x,t_y)

使用DataLoader按照想要的方式打乱数据(交叉验证)(截止至到这步，数据集做好了)

#shuffle=True是打乱数据,batch_size=1000是每批次1000个数据
train_loader=torch.utils.data.DataLoader(dataset=train_dataset,shuffle=True,batch_size=1000)
#测试集直接弄10000个数据
test_loader=torch.utils.data.DataLoader(dataset=test_dataset,shuffle=True,batch_size=10000)

决策模型（此处只需继承类torch.nn.Moudle，按这个类去实施就可以）

class LeNet_5(torch.nn.Module):
    # 构造器 (overload):定义层
    def __init__(self):
        super(LeNet_5, self).__init__() #初始化父类成员
        
        #layer1:-1, 1, 28, 28；-1是计算时候根据后面的值动态计算前面的值；卷积层，这个是一张图像变六张那个：6 ，28 ，28
        #in_channels是输入通道（此处输入1张图像），out_channels是输出通道（此处输出6张图像）,kernel_size=(5,5)卷积核是5*5
        self.layer1=torch.nn.Conv2d(in_channels=1, out_channels=6, kernel_size=(5, 5), padding=2)
        
        #layer2,卷积层
        self.layer2=torch.nn.Conv2d(in_channels=6, out_channels=16, kernel_size=(5, 5))
        
        #layer3，卷积层
        self.layer3=torch.nn.Conv2d(in_channels=16, out_channels=120, kernel_size=(5, 5))
        
        #layer4,线形层,输入120.输出84
        self.layer4=torch.nn.Linear(120,84)
        
        #layer5，线形层,输入84.输出10
        self.layer5=torch.nn.Linear(84,10)
    
    
    # forward（overload）:使用层构建网络（决策输出）
    def forward(self,input):
        o = self.layer1(input)
        o =torch.nn.functional.relu(o)
        o =torch.nn.functional.max_pool2d(o,kernel_size=(2,2))#池化降维
        
        o = self.layer2(o)
        o =torch.nn.functional.relu(o)
        o =torch.nn.functional.max_pool2d(o,kernel_size=(2,2))#池化降维
        
        o = self.layer3(o)
        o =torch.nn.functional.relu(o)
        
        #格式处理
        o = o.squeeze()
        
        o = self.layer4(o)
        o =torch.nn.functional.relu(o)
        
        o = self.layer5(o)
        o =torch.nn.functional.log_softmax(o,dim=1)
        
        return o

构建模型

epoch=200
#决策模型
model=LeNet_5()
#损失模型
criterion=torch.nn.CrossEntropyLoss()
#优化模型
optimizer=torch.optim.Adam(model.parameters(), lr=0.001)

for n in range(epoch):
    for data, target in train_loader:
        # 先清空梯度
        optimizer.zero_grad()
        # 计算决策输出
        out = model(data)     # 可调用对象
        # 计算损失
        loss = criterion(out, target)
        # 计算梯度
        loss.backward()
        # 更新梯度
        optimizer.step()   # w.grad
    with torch.no_grad():
        for test_data, test_target in  test_loader:
            pre_y = model(test_data) 
            predict = torch.argmax(pre_y, dim=1)
            corr_r = (predict == test_target).float().mean()
            print(F"损失度：{loss:2.6f},\t准确率：{corr_r * 100:6.2f}%")

print("------------训练结束--------------------")

损失度：0.185136,	准确率： 95.43%
损失度：0.079384,	准确率： 97.20%
损失度：0.060514,	准确率： 97.58%
损失度：0.055597,	准确率： 98.13%
损失度：0.024336,	准确率： 98.15%
损失度：0.036571,	准确率： 98.40%
损失度：0.029954,	准确率： 98.19%
损失度：0.031486,	准确率： 98.32%
损失度：0.019577,	准确率： 98.58%
损失度：0.021823,	准确率： 98.54%
损失度：0.013632,	准确率： 98.50%
损失度：0.023166,	准确率： 98.58%
损失度：0.014416,	准确率： 98.66%
损失度：0.015094,	准确率： 98.81%
损失度：0.029611,	准确率： 98.53%
损失度：0.010244,	准确率： 98.69%
损失度：0.016683,	准确率： 98.63%
损失度：0.009074,	准确率： 98.76%
损失度：0.007117,	准确率： 98.79%
损失度：0.004928,	准确率： 98.68%
损失度：0.002845,	准确率： 98.75%
损失度：0.006522,	准确率： 98.70%
损失度：0.002661,	准确率： 98.78%
损失度：0.008203,	准确率： 98.77%
损失度：0.000669,	准确率： 98.82%
损失度：0.002472,	准确率： 98.70%
损失度：0.011594,	准确率： 98.59%
损失度：0.008643,	准确率： 98.52%
损失度：0.013747,	准确率： 98.62%
损失度：0.007663,	准确率： 98.77%
损失度：0.006473,	准确率： 98.65%
损失度：0.002827,	准确率： 98.77%
损失度：0.007185,	准确率： 98.63%
损失度：0.005448,	准确率： 98.60%
损失度：0.001339,	准确率： 98.87%
损失度：0.002555,	准确率： 98.70%
损失度：0.001698,	准确率： 98.85%
损失度：0.002510,	准确率： 98.72%
损失度：0.002146,	准确率： 98.75%
损失度：0.008151,	准确率： 98.85%
损失度：0.004149,	准确率： 98.64%
损失度：0.004940,	准确率： 98.85%
损失度：0.001040,	准确率： 98.91%
损失度：0.009507,	准确率： 98.95%
损失度：0.000859,	准确率： 98.91%
损失度：0.005697,	准确率： 98.43%
损失度：0.010407,	准确率： 98.69%
损失度：0.003661,	准确率： 98.72%
损失度：0.004555,	准确率： 98.88%
损失度：0.015984,	准确率： 98.61%
损失度：0.004690,	准确率： 98.89%
损失度：0.002076,	准确率： 98.81%
损失度：0.004873,	准确率： 98.72%
损失度：0.006220,	准确率： 98.98%
损失度：0.001060,	准确率： 98.69%
损失度：0.001400,	准确率： 98.83%
损失度：0.004788,	准确率： 98.76%
损失度：0.006157,	准确率： 98.87%
损失度：0.005031,	准确率： 98.63%
损失度：0.004350,	准确率： 98.78%
损失度：0.002579,	准确率： 98.79%
损失度：0.017134,	准确率： 98.82%
损失度：0.010333,	准确率： 98.77%
损失度：0.003919,	准确率： 98.78%
损失度：0.001525,	准确率： 98.87%
损失度：0.008966,	准确率： 99.05%
损失度：0.009587,	准确率： 98.98%
损失度：0.000194,	准确率： 99.06%
损失度：0.000033,	准确率： 99.11%
损失度：0.000037,	准确率： 99.18%
损失度：0.000034,	准确率： 99.13%
损失度：0.000026,	准确率： 99.14%
损失度：0.000039,	准确率： 99.14%
损失度：0.000015,	准确率： 99.13%
损失度：0.000004,	准确率： 99.13%
损失度：0.000010,	准确率： 99.13%
损失度：0.000012,	准确率： 99.13%
损失度：0.000010,	准确率： 99.13%
损失度：0.000006,	准确率： 99.13%
损失度：0.000006,	准确率： 99.14%
损失度：0.000007,	准确率： 99.14%
损失度：0.000009,	准确率： 99.14%
损失度：0.000013,	准确率： 99.14%
损失度：0.000005,	准确率： 99.16%
损失度：0.000007,	准确率： 99.15%
损失度：0.000002,	准确率： 99.15%
损失度：0.000005,	准确率： 99.16%
损失度：0.000010,	准确率： 99.16%
损失度：0.000004,	准确率： 99.16%
损失度：0.000007,	准确率： 99.16%
损失度：0.000004,	准确率： 99.16%
损失度：0.000002,	准确率： 99.15%
损失度：0.000003,	准确率： 99.15%
损失度：0.000005,	准确率： 99.15%
损失度：0.000003,	准确率： 99.17%
损失度：0.000005,	准确率： 99.16%
损失度：0.000004,	准确率： 99.16%
损失度：0.000002,	准确率： 99.16%
损失度：0.000004,	准确率： 99.16%
损失度：0.000002,	准确率： 99.16%
损失度：0.000003,	准确率： 99.17%
损失度：0.000004,	准确率： 99.17%
损失度：0.000001,	准确率： 99.17%
损失度：0.000003,	准确率： 99.17%
损失度：0.000003,	准确率： 99.17%
损失度：0.000003,	准确率： 99.17%
损失度：0.000005,	准确率： 99.16%
损失度：0.000002,	准确率： 99.17%
损失度：0.000003,	准确率： 99.16%
损失度：0.000004,	准确率： 99.16%
损失度：0.000004,	准确率： 99.16%
损失度：0.000001,	准确率： 99.16%
损失度：0.000001,	准确率： 99.16%
损失度：0.000002,	准确率： 99.16%
损失度：0.000002,	准确率： 99.16%
损失度：0.000001,	准确率： 99.16%
损失度：0.000002,	准确率： 99.16%
损失度：0.000002,	准确率： 99.16%
损失度：0.000001,	准确率： 99.16%
损失度：0.000001,	准确率： 99.16%
损失度：0.000000,	准确率： 99.17%
损失度：0.000001,	准确率： 99.17%
损失度：0.000002,	准确率： 99.17%
损失度：0.000002,	准确率： 99.17%
损失度：0.000002,	准确率： 99.17%
损失度：0.000001,	准确率： 99.17%
损失度：0.000002,	准确率： 99.17%
损失度：0.000000,	准确率： 99.17%
损失度：0.000002,	准确率： 99.17%
损失度：0.000002,	准确率： 99.17%
损失度：0.000001,	准确率： 99.17%
损失度：0.000001,	准确率： 99.17%
损失度：0.000002,	准确率： 99.17%
损失度：0.000001,	准确率： 99.17%
损失度：0.000001,	准确率： 99.17%
损失度：0.000001,	准确率： 99.17%
损失度：0.000002,	准确率： 99.17%
损失度：0.000001,	准确率： 99.17%
损失度：0.000001,	准确率： 99.17%
损失度：0.000001,	准确率： 99.17%
损失度：0.000001,	准确率： 99.17%
损失度：0.000001,	准确率： 99.17%
损失度：0.000001,	准确率： 99.17%
损失度：0.000001,	准确率： 99.17%
损失度：0.000000,	准确率： 99.17%
损失度：0.000001,	准确率： 99.17%
损失度：0.000001,	准确率： 99.17%
损失度：0.000001,	准确率： 99.17%
损失度：0.000001,	准确率： 99.17%
损失度：0.000000,	准确率： 99.17%
损失度：0.000001,	准确率： 99.17%
损失度：0.000001,	准确率： 99.18%
损失度：0.000000,	准确率： 99.17%
损失度：0.000001,	准确率： 99.17%
损失度：0.000001,	准确率： 99.17%
损失度：0.000001,	准确率： 99.17%
损失度：0.000000,	准确率： 99.17%
损失度：0.000001,	准确率： 99.17%
损失度：0.000000,	准确率： 99.18%
损失度：0.000001,	准确率： 99.17%
损失度：0.000000,	准确率： 99.18%
损失度：0.000001,	准确率： 99.18%
损失度：0.000000,	准确率： 99.18%
损失度：0.000001,	准确率： 99.17%
损失度：0.000001,	准确率： 99.18%
损失度：0.000001,	准确率： 99.18%
损失度：0.000000,	准确率： 99.19%
损失度：0.000001,	准确率： 99.19%
损失度：0.000000,	准确率： 99.18%
损失度：0.000000,	准确率： 99.19%
损失度：0.000000,	准确率： 99.18%
损失度：0.000000,	准确率： 99.17%
损失度：0.000001,	准确率： 99.18%
损失度：0.000000,	准确率： 99.18%
损失度：0.000000,	准确率： 99.17%
损失度：0.000000,	准确率： 99.19%
损失度：0.000000,	准确率： 99.16%
损失度：0.000000,	准确率： 99.17%
损失度：0.000001,	准确率： 99.16%
损失度：0.000000,	准确率： 99.18%
损失度：0.000000,	准确率： 99.16%
损失度：0.000000,	准确率： 99.17%
损失度：0.000000,	准确率： 99.17%
损失度：0.000000,	准确率： 99.16%
损失度：0.000000,	准确率： 99.16%
损失度：0.000000,	准确率： 99.15%
损失度：0.000000,	准确率： 99.15%
损失度：0.000000,	准确率： 99.14%
损失度：0.000000,	准确率： 99.14%
损失度：0.000000,	准确率： 99.14%
损失度：0.000000,	准确率： 99.15%
损失度：0.000000,	准确率： 99.15%
损失度：0.000000,	准确率： 99.14%
损失度：0.000000,	准确率： 99.13%
损失度：0.000000,	准确率： 99.13%
损失度：0.000000,	准确率： 99.14%
损失度：0.000000,	准确率： 99.16%
损失度：0.000000,	准确率： 99.13%
损失度：0.000000,	准确率： 99.14%
损失度：0.000000,	准确率： 99.13%
------------训练结束--------------------
遨游的菜鸡
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
深度学习------不同方法实现lenet-5模型
m0_47405013的博客
06-22 105
本博客通过tensorflow和pytorch实现lenet-5模型，对于lenet-5模型有不同的写法，包括，sequence模型、类封装、自定义函数，而本博客主要对这三种写法做主要介绍，代码和图如下： 2. tensofflow通过类实现lenet-5 3. tensofflow通过自定义函数实现lenet-5 4. pytorch通过sequence实现lenet-5 4.1 mnist数据集 4.2 cifar10数据集...
lenet5实现手写数字识别---python
sinat_39288187的博客
05-15 8776
​​​​​​lenet5实现手写数字识别 一. 导入数据集 下载数据集 查看第一张图片的尺寸 输出数据集规模 可知图片尺寸为28*28像素，通道数为1。训练集包含55000张图片，验证集包含5000张图片，测试集包含10000张图片 将训练集进行填充 # 因为mnist数据集的图片是28*28*1的格式，而lenet只接受32*32的格式 # 所以只能在这个基础上...
Pytorch从入门到放弃（1）——实现经典神经网络模型LeNet5
Enochzhu的博客
02-11 323
由于一些原因，需要使用Pytorch深度学习框架。先后也接触了Caffe、TesorFlow、Pytorch这三个深度学习框架，以后也许会更多，个人觉得这些框架大同小异不必全都掌握，精通一个即可，没有办法上面要求没办法，让你用啥你就得用啥。个人觉得这三个框架安装起来要数Caffe安装起来最麻烦，但是在网络模型的修改与扩展上，个人觉得Caffe最舒服，Caffe有专门的网络定义文件，在上面修改一下即...
常用的卷积神经网络——LeNet-5(1990‘s)代码实现
AI R&D
02-23 1553
对于python/pytorch初学者，可以先熟悉python中类的使用，以及nn.Module模块的相关定义 python中类的init()的两种定义方式：python def init(self, name等多参数), def init(self) super（）以及python2和python3中使用super()的不同点：python中super().init() 在继承 nn.Module 的神经网络模块在实现自己的 init 函数时，一定要先调用 super().init()。只有这样才能正确
pytorch实战1：手把手教你基于pytorch实现LeNet5
weixin_46676835的博客
01-17 3279
pytorch实战1：手把手教你基于pytorch实现LeNet5
LeNet-5识别MNIST手写数字数据集（PyTorch）
10-14
本教程将深入讲解如何使用PyTorch实现LeNet-5来处理MNIST手写数字数据集。 **一、MNIST手写数字数据集** MNIST是Machine Learning的一个经典数据集，包含60,000个训练样本和10,000个测试样本，每个样本都是28x28...
LeNet-5pytorch实战.pdf
06-05
下面我们将深入探讨LeNet-5的网络结构、原理以及在Pytorch框架下的代码实现和对数据集的训练测试。 ### LeNet-5网络结构和原理 #### 1. LeNet-5网络介绍 LeNet-5由Yann LeCun等人提出，于1998年发表，是卷积神经...
LeNet-5:LeNet-5的PyTorch实施和实时可视化
05-04
这实现了略微修改的LeNet-5 [LeCun et al。，1998a]，并在上达到了约99％的准确度。 设置 使用以下命令安装所有依赖项 $ pip install -r requirements.txt 用法 启动visdom服务器进行可视化 $ python -m visdom....
Pytorch CIFAR-10分类（LeNet5）.ipynb
10-02
Pytorch CIFAR-10分类（LeNet5）
pytorch实现lenet5
08-14
《PyTorch 实现 LeNet-5：深度学习在 MNIST 数据集上的应用》 LeNet-5，由Yann LeCun等人于1998年提出，是最早的卷积神经网络（Convolutional Neural Network, CNN）之一，主要用于手写数字识别任务。在PyTorch框架...
LetNet5网络结构详解
dear_queen的博客
10-07 6069
LetNet5 这个是其网络结构。 下面我们详细介绍该网络结构，在此之前，先约定一些称呼：feature maps（f.maps）是每层网络的特征图；stride是卷积核的步长；C1层的特征图大小为28×28×6，其中28×28表示特征图的高度×宽度，6表示特征图的通道数；该层使用的卷积核大小5×5×1×6，表示高度×宽度×输入通道数×输出通道数。 首先是输入层，输入图像大小统一归一化为32×32，在正式输入网络之前，其灰度值也要进行归一化。 第一个卷积层C1， 其经过大小为5×5×1×6的卷积核（str
PyTorch之LeNet-5：利用PyTorch实现最经典的LeNet-5卷积神经网络对手写数字图片识别CNN
热门推荐
近期请国内外头部出版社可尽快私信博主！——心比天高，仗剑走天涯，保持热爱，奔赴向梦想！低调，谦虚，自律，反思，成长，还算是比较正能量的博主，公益免费传播……内心特别想在AI界做出一些可以推进历史进程影响力的东西(兴趣使然，有点小情怀，也有点使命感呀)…
05-06 2万+
PyTorch之LeNet-5：利用PyTorch实现最经典的LeNet-5卷积神经网络对手写数字图片识别CNN 目录 训练过程 代码设计 训练过程 代码设计 #PyTorch：利用PyTorch实现最经典的LeNet卷积神经网络对手写数字进行识别CNN——Jason niu import torch import torch...
conv2d原理、计算过程、pytorch使用
纸上得来终觉浅，绝知此事要躬行！
12-30 1万+
文章目录conv2d卷积过程单通道三（多）通道多个输出通道（**即改变输出通道**）对应代码 【学习于刘二大大视频：https://www.bilibili.com/video/BV1Y7411d7Ys?p=10】 conv2d 卷积过程 向两个维度进行卷积 单通道 三（多）通道 一个通道需要一个kernel 画图： 多个输出通道（即改变输出通道） 卷积核的数量==输出通道的通道数 每个卷积核的数量==输入通道的通道数 对应代码 self.conv1 = nn.Conv2d(in_channel
Python中辨析type/dtype/astype用法
Meiko记录
02-27 1万+
Python中与数据类型相关函数及属性有如下三个：type/dtype/astype。 名称 描述 type() 返回参数的数据类型 dtype 返回数组中元素的数据类型 astype() 对数据类型进行转换 type()用于获取数据类型 #type用于获取数据类型 import numpy as np a=[1,2,3] print(type(a)) #...
【深度学习实战—3】：基于LetNet-5的手写数字识别（附Keras实现）
王乐予的博客
03-27 9477
目录😺一、数据集获取😺二、定义LeNet-5😺三、编译并训练😺四、测试模型😺五、预测结果可视化😺六、建立混淆矩阵😺附录：完整程序 当我们学习了LeNet-5网络和MNIST数据集之后，就要将经典网络用于实战中了！文末附完整程序！ 😺一、数据集获取 """ 数据集获取 """ def get_mnist_dat.
K210 车牌识别项目单片机代码，所用语言为C语言
最新发布
08-24
K210 车牌识别项目单片机代码，所用语言为C语言
源代码-博购企业名录搜索软站留言簿.zip
08-24
源代码-博购企业名录搜索软站留言簿.zip
项目使用华为云_ModelArts_AI_开发平台进行训练部署，
08-24
项目使用华为云_ModelArts_AI_开发平台进行训练部署，采用_Mask_R-CNN_算法模型_ma-mask-rcnn
女弓箭手射箭动画动作：Stylish Archer Assets Pack 1.4
08-24
时尚射手行动包 包括与演示视频相同的角色和武器建模文件。 运动状态已与动画控制器对齐。 产品信息 角色联盟被设置为类人配置。包括5根手指骨、肩臂和腿部扭转骨。 所有动画都包含在内。 弓箭手包总计：454 攻击力：97 移动：38 起立和坐下：4 蹲伏移动：11 蹲下-行走：16 蹲下_行走_瞄准：16 重新加载 : 9 蹲下_瞄准_射击：2 道奇：8 慢跑：20 技能 : 46 步行_目标：16 + 18（版本1.2） 步行：16 装备与解除装备：2 跳跃和双跳：28 空袭：8 移动转身：44 伤害：23 模具：3个 可拆卸：29 （这是原地运动和根运动的总和。）
LeNet-5 PyTorch实战：经典CNN结构与应用详解
文章的实现部分，作者使用PyTorch语言重新实现了LeNet-5，并将其应用于MNIST手写数字识别和CIFAR10数据集的训练与测试，旨在帮助读者通过实践进一步掌握这一经典模型。学习和实践LeNet-5不仅能帮助读者理解CNN的历史...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值