所需数据
在 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.在卷积运算添加一个偏置项,对图像的灰度有脱敏效果
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%
------------训练结束--------------------