PyTorch（五）MNIST手写数字识别（实战）（下）

b站视频&＃xff08;11&＃xff0c;12&＃xff0c;13&＃xff09;&＃xff1a;https://www.bilibili.com/video/av49008640/?p&＃61;11

上篇博客&＃xff1a;https://blog.csdn.net/zjc910997316/article/details/93169277

使用的是CPU,没有用CUDA

PyTorch---&＃xff08;四&＃xff09;MNIST 手写数字识别 &＃xff08;实战&＃xff09;&＃xff08;上&＃xff09;

两个文件如下&＃xff0c;在此基础是上构建一个网络

文件1&＃xff1a;辅助文件utils.py

# utils.py
import torch
from matplotlib import pyplot as pltdef plot_curve(data): #下降曲线的绘制fig &＃61; plt.figure()plt.plot(range(len(data)), data, color&＃61;&＃39;blue&＃39;) #plt.legend([&＃39;value&＃39;], loc&＃61;&＃39;upper right&＃39;) #plt.xlabel(&＃39;step&＃39;)plt.ylabel(&＃39;value&＃39;)plt.show()def plot_image(img, label, name): # 画图片&＃xff0c;帮助看识别结果fig &＃61; plt.figure()for i in range(6): # 6个图像&＃xff0c;两行三列# print(i) 012345plt.subplot(2, 3, i&＃43;1)plt.tight_layout() # 紧密排版plt.imshow(img[i][0]*0.3081&＃43;0.1307, cmap&＃61;&＃39;gray&＃39;, interpolation&＃61;&＃39;none&＃39;) # 均值是0.1307&＃xff0c;标准差是0.3081&＃xff0c;plt.title("{}:{}".format(name, label[i].item())) # name:image_sample label[i].item():数字plt.xticks([])plt.yticks([])plt.show()def one_hot(label, depth&＃61;10):out &＃61; torch.zeros(label.size(0), depth)idx &＃61; torch.LongTensor(label).view(-1, 1)out.scatter_(dim&＃61;1, index&＃61;idx, value&＃61;1)return out


文件2&＃xff1a;主文件&＃xff0c;mnist_train.py

#mnist_train.py 1.0import torch
from torch import nn
from torch.nn import functional as F
from torch import optimimport torchvision
from matplotlib import pyplot as pltfrom utils import plot_curve, plot_image, one_hotbatch_size &＃61; 512
# step1.load_dataset
# &＃39;mnist_data&＃39;&＃xff1a;加载mnist数据集&＃xff0c;路径
# train&＃61;True&＃xff1a;选择训练集还是测试
# download&＃61;True&＃xff1a;如果当前文件没有mnist文件就会自动从网上去下载
# torchvision.transforms.ToTensor():下载好的数据一般是numpy格式&＃xff0c;转换成Tensor
# torchvision.transforms.Normalisze((0.1307,), (0.3081,))&＃xff1a;正则化过程&＃xff0c;为了让数据更好的在0的附近均匀的分布
# 上面一行可注释掉&＃xff1a;但是性能会差到百分之70&＃xff0c;加上是百分之80&＃xff0c;更加方便神经网络去优化train_loader &＃61; torch.utils.data.DataLoader( # 加载训练集torchvision.datasets.MNIST(&＃39;mnist_data&＃39;, train&＃61;True, download&＃61;True,transform&＃61;torchvision.transforms.Compose([torchvision.transforms.ToTensor(),torchvision.transforms.Normalize((0.1307,), (0.3081,)) # 均值是0.1307&＃xff0c;# 标准差是0.3081&＃xff0c;这些系数都是数据集提供方计算好的数据])),batch_size&＃61;batch_size, shuffle&＃61;True)
# batch_size&＃61;batch_size&＃xff1a;表示一次加载多少张图片
# shuffle &＃61; True 加载的时候做一个随机的打散test_loader &＃61; torch.utils.data.DataLoader( # 加载测试集torchvision.datasets.MNIST(&＃39;mnist_data/&＃39;, train&＃61;False, download&＃61;True,transform&＃61;torchvision.transforms.Compose([torchvision.transforms.ToTensor(),torchvision.transforms.Normalize((0.1307,), (0.3081,))])),batch_size&＃61;batch_size, shuffle&＃61;False) # 测试集不用打散x, y &＃61; next(iter(train_loader))
print(x.shape, y.shape)
# print(x.min(), x.max())
# plot_image(x, y, &＃39;image_sample&＃39;)


1 在文件2: mnist_train.py上面做了修改

# ------------后面是本节新加入部分------------

在上述标记后面是新加入内容

#mnist_train.py 2.0 加入训练过程import torch
from torch import nn
from torch.nn import functional as F
from torch import optimimport torchvision
from matplotlib import pyplot as pltfrom utils import plot_curve, plot_image, one_hotbatch_size &＃61; 512
# step1.load_dataset
# &＃39;mnist_data&＃39;&＃xff1a;加载mnist数据集&＃xff0c;路径
# train&＃61;True&＃xff1a;选择训练集还是测试
# download&＃61;True&＃xff1a;如果当前文件没有mnist文件就会自动从网上去下载
# torchvision.transforms.ToTensor():下载好的数据一般是numpy格式&＃xff0c;转换成Tensor
# torchvision.transforms.Normalisze((0.1307,), (0.3081,))&＃xff1a;正则化过程&＃xff0c;为了让数据更好的在0的附近均匀的分布
# 上面一行可注释掉&＃xff1a;但是性能会差到百分之70&＃xff0c;加上是百分之80&＃xff0c;更加方便神经网络去优化train_loader &＃61; torch.utils.data.DataLoader( # 加载训练集torchvision.datasets.MNIST(&＃39;mnist_data&＃39;, train&＃61;True, download&＃61;True,transform&＃61;torchvision.transforms.Compose([torchvision.transforms.ToTensor(),# torchvision.transforms.Normalize(# (0.1307,), (0.3081,))])),batch_size&＃61;batch_size, shuffle&＃61;True)
# batch_size&＃61;batch_size&＃xff1a;表示一次加载多少张图片
# shuffle &＃61; True 加载的时候做一个随机的打散test_loader &＃61; torch.utils.data.DataLoader( # 加载测试集torchvision.datasets.MNIST(&＃39;mnist_data/&＃39;, train&＃61;False, download&＃61;True,transform&＃61;torchvision.transforms.Compose([torchvision.transforms.ToTensor(),torchvision.transforms.Normalize((0.1307,), (0.3081,)) # 均值是0.1307&＃xff0c;标准差是0.3081&＃xff0c;# 这些系数都是数据集提供方计算好的数据])),batch_size&＃61;batch_size, shuffle&＃61;False) # 测试集不用打散x, y &＃61; next(iter(train_loader))
print(x.shape, y.shape, x.min(), x.max())
# plot_image(x, y, &＃39;image_sample&＃39;)# ------------后面是本节新加入部分------------
class Net(nn.Module):def __init__(self): # 初始化函数super(Net, self).__init__()# 新建三层 xw&＃43;b是一层self.fc1 &＃61; nn.Linear(28*28, 256) # 这里的256是随机决定&＃xff0c;小维度是这样的&＃xff0c;经验self.fc2 &＃61; nn.Linear(256, 64)self.fc3 &＃61; nn.Linear(64, 10) # 28*28&＃61;784是输入&＃xff0c; 10是10种分类&＃xff0c;这两个是固定的。 256和64是经验决定def forward(self, x):# h1 &＃61; relu(xw&＃43;b) x: [b, 1, 28, 28]x &＃61; F.relu(self.fc1(x))# h2 &＃61; relu(h1w2&＃43;b2)x &＃61; F.relu(self.fc2(x))# h3 &＃61; h2w3&＃43;b3 最后一层加不加激活函数取决于具体的任务&＃xff0c;输出是输出概率值x &＃61; self.fc3(x) # 分类问题一般是softmax &＃43; mean squre error均方差 &＃xff0c;简单起见直接使用softmaxreturn xnet &＃61; Net() # 完成一个实例化# net.parameters(): 会帮我们拿到权值 [w1, b1, w2, b2, w3, b3]
# momentum: 动量&＃xff0c;帮助更好的优化的一个策略&＃xff0c;后面会讲
# lv: 学习率
optimizer &＃61; optim.SGD(net.parameters(), lr&＃61;0.01, momentum&＃61;0.9) # 梯度下降的优化器for epoch in range(3): # 对整个数据集迭代3遍for batch_idx, (x, y) in enumerate(train_loader): # 对整个数据集迭代一次# 这里是对一个batch迭代一次&＃xff0c;一次batch 512张图片# print(x.shape, y.shape) 输入 torch.Size([512, 1, 28, 28]) 输出 torch.Size([512])# x: [b, 1, 28, 28], y: [512]# 需要把输入tensor[b, 1, 28, 28] -> 打平为下面[b, feature]# [b, 1, 28, 28] &＃61;> [b, 784]# x.view 参考&＃xff1a;https://blog.csdn.net/zjc910997316/article/details/93472186x &＃61; x.view(x.size(0), 28*28) # x.size(0)表示batch 512 (512, 1, 28, 28) -> (512, 748)# &＃61;> [b, 10]out &＃61; net(x) # 经过了class Net(nn.Module):# [b, 10]y_onehot &＃61; one_hot(y)# loss &＃61; mse(out, y_onehot) mse 是 均方差 mean squre errorloss &＃61; F.mse_loss(out, y_onehot) # todo 1&＃xff1a;计算out与y_onehot之间的均方差&＃xff0c;得到lossoptimizer.zero_grad() # 先对梯度进行清零loss.backward() # todo 2&＃xff1a;梯度计算过程&＃xff0c;计算梯度# w&＃39; &＃61; w - lr*grad learn rate学习率optimizer.step() # todo 3&＃xff1a;更新权值if batch_idx % 10 &＃61;&＃61; 0: # 每隔10个batch打印一下print(epoch, batch_idx, loss.item()) # 第几个大循环&＃xff08;一共3个&＃xff09;&＃xff0c; 第多少批次eg:10 20 30 , loss显示# we get optimal [w1, b1, w2, b2, w3, b3]


输出结果如下&＃xff1a;&＃xff08;迭代三轮&＃xff0c;输出分别是&＃xff0c;轮次&＃xff0c;批次&＃xff0c;loss&＃xff09;

G:\nk_deeplearning\Anaconda\python.exe G:/nk_PyCharm/ProjectPython37/1_学习/code2_手写数字识别/mnist_train.py
torch.Size([512, 1, 28, 28]) torch.Size([512]) tensor(0.) tensor(1.)
0 0 0.1072411835193634
0 10 0.10040384531021118
0 20 0.09393098950386047
0 30 0.08950097858905792
0 40 0.08756093680858612
0 50 0.08633685857057571
0 60 0.08495817333459854
0 70 0.08355747908353806
0 80 0.08264319598674774
0 90 0.08139751851558685
0 100 0.08043213188648224
0 110 0.07888615876436234
1 0 0.0783829465508461
1 10 0.077311672270298
1 20 0.07582336664199829
1 30 0.07455351948738098
1 40 0.07390157133340836
1 50 0.070893295109272
1 60 0.07046789675951004
1 70 0.06924404948949814
1 80 0.06765957176685333
1 90 0.06644198298454285
1 100 0.0647168755531311
1 110 0.0634407103061676
2 0 0.06439292430877686
2 10 0.062066979706287384
2 20 0.06103499233722687
2 30 0.060522183775901794
2 40 0.05999534949660301
2 50 0.0591929629445076
2 60 0.05758301913738251
2 70 0.057452309876680374
2 80 0.05596078187227249
2 90 0.05296340212225914
2 100 0.05490083619952202
2 110 0.05447380617260933

2 帮助可视化

# &＃64;&＃64;&＃64;1

# &＃64;&＃64;&＃64;2

# &＃64;&＃64;&＃64;3

完整代码&＃xff1a;

#mnist_train.py 3.0 加入可视化组件 ---新加入标记如下# &＃64;&＃64;&＃64;1 # &＃64;&＃64;&＃64;2 # &＃64;&＃64;&＃64;3import torch
from torch import nn
from torch.nn import functional as F
from torch import optimimport torchvision
from matplotlib import pyplot as pltfrom utils import plot_curve, plot_image, one_hotbatch_size &＃61; 512
# step1.load_dataset
# &＃39;mnist_data&＃39;&＃xff1a;加载mnist数据集&＃xff0c;路径
# train&＃61;True&＃xff1a;选择训练集还是测试
# download&＃61;True&＃xff1a;如果当前文件没有mnist文件就会自动从网上去下载
# torchvision.transforms.ToTensor():下载好的数据一般是numpy格式&＃xff0c;转换成Tensor
# torchvision.transforms.Normalisze((0.1307,), (0.3081,))&＃xff1a;正则化过程&＃xff0c;为了让数据更好的在0的附近均匀的分布
# 上面一行可注释掉&＃xff1a;但是性能会差到百分之70&＃xff0c;加上是百分之80&＃xff0c;更加方便神经网络去优化train_loader &＃61; torch.utils.data.DataLoader( # 加载训练集torchvision.datasets.MNIST(&＃39;mnist_data&＃39;, train&＃61;True, download&＃61;True,transform&＃61;torchvision.transforms.Compose([torchvision.transforms.ToTensor(),# torchvision.transforms.Normalize(# (0.1307,), (0.3081,))])),batch_size&＃61;batch_size, shuffle&＃61;True)
# batch_size&＃61;batch_size&＃xff1a;表示一次加载多少张图片
# shuffle &＃61; True 加载的时候做一个随机的打散test_loader &＃61; torch.utils.data.DataLoader( # 加载测试集torchvision.datasets.MNIST(&＃39;mnist_data/&＃39;, train&＃61;False, download&＃61;True,transform&＃61;torchvision.transforms.Compose([torchvision.transforms.ToTensor(),torchvision.transforms.Normalize((0.1307,), (0.3081,)) # 均值是0.1307&＃xff0c;标准差是0.3081&＃xff0c;# 这些系数都是数据集提供方计算好的数据])),batch_size&＃61;batch_size, shuffle&＃61;False) # 测试集不用打散x, y &＃61; next(iter(train_loader))
print(x.shape, y.shape, x.min(), x.max())
# plot_image(x, y, &＃39;image_sample&＃39;)# ------------后面是本节新加入部分------------
class Net(nn.Module):def __init__(self): # 初始化函数super(Net, self).__init__()# 新建三层 xw&＃43;b是一层self.fc1 &＃61; nn.Linear(28*28, 256) # 这里的256是随机决定&＃xff0c;小维度是这样的&＃xff0c;经验self.fc2 &＃61; nn.Linear(256, 64)self.fc3 &＃61; nn.Linear(64, 10) # 28*28&＃61;784是输入&＃xff0c; 10是10种分类&＃xff0c;这两个是固定的。 256和64是经验决定def forward(self, x):# h1 &＃61; relu(xw&＃43;b) x: [b, 1, 28, 28]x &＃61; F.relu(self.fc1(x))# h2 &＃61; relu(h1w2&＃43;b2)x &＃61; F.relu(self.fc2(x))# h3 &＃61; h2w3&＃43;b3 最后一层加不加激活函数取决于具体的任务&＃xff0c;输出是输出概率值x &＃61; self.fc3(x) # 分类问题一般是softmax &＃43; mean squre error均方差 &＃xff0c;简单起见直接使用softmaxreturn xnet &＃61; Net() # 完成一个实例化# net.parameters(): 会帮我们拿到权值 [w1, b1, w2, b2, w3, b3]
# momentum: 动量&＃xff0c;帮助更好的优化的一个策略&＃xff0c;后面会讲
# lv: 学习率
optimizer &＃61; optim.SGD(net.parameters(), lr&＃61;0.01, momentum&＃61;0.9) # 梯度下降的优化器train_loss &＃61; [] # &＃64;&＃64;&＃64;1for epoch in range(3): # 对整个数据集迭代3遍for batch_idx, (x, y) in enumerate(train_loader): # 对整个数据集迭代一次# 这里是对一个batch迭代一次&＃xff0c;一次batch 512张图片# print(x.shape, y.shape) 输入 torch.Size([512, 1, 28, 28]) 输出 torch.Size([512])# x: [b, 1, 28, 28], y: [512]# 需要把输入tensor[b, 1, 28, 28] -> 打平为下面[b, feature]# [b, 1, 28, 28] &＃61;> [b, 784]# x.view 参考&＃xff1a;https://blog.csdn.net/zjc910997316/article/details/93472186x &＃61; x.view(x.size(0), 28*28) # x.size(0)表示batch 512 (512, 1, 28, 28) -> (512, 748)# &＃61;> [b, 10]out &＃61; net(x) # 经过了class Net(nn.Module):# [b, 10]y_onehot &＃61; one_hot(y)# loss &＃61; mse(out, y_onehot) mse 是 均方差 mean squre errorloss &＃61; F.mse_loss(out, y_onehot) # todo 1&＃xff1a;计算out与y_onehot之间的均方差&＃xff0c;得到lossoptimizer.zero_grad() # 先对梯度进行清零loss.backward() # todo 2&＃xff1a;梯度计算过程&＃xff0c;计算梯度# w&＃39; &＃61; w - lr*grad learn rate学习率optimizer.step() # todo 3&＃xff1a;更新权值train_loss.append(loss.item()) # &＃64;&＃64;&＃64;2if batch_idx % 10 &＃61;&＃61; 0: # 每隔10个batch打印一下print(epoch, batch_idx, loss.item()) # 第几个大循环&＃xff08;一共3个&＃xff09;&＃xff0c; 第多少批次eg:10 20 30 , loss显示plot_curve(train_loss) # &＃64;&＃64;&＃64;3
# we get optimal [w1, b1, w2, b2, w3, b3]


输出同上

多了一副图

3 loss只是一个辅助指标&＃xff0c;correct才是真正指标

下面标记是新加入部分

# ------------后面是本节新加入部分------------

完整代码&＃xff1a;

import torch
from torch import nn
from torch.nn import functional as F
from torch import optimimport torchvision
from matplotlib import pyplot as pltfrom utils import plot_curve, plot_image, one_hotbatch_size &＃61; 512
# step1.load_dataset
# &＃39;mnist_data&＃39;&＃xff1a;加载mnist数据集&＃xff0c;路径
# train&＃61;True&＃xff1a;选择训练集还是测试
# download&＃61;True&＃xff1a;如果当前文件没有mnist文件就会自动从网上去下载
# torchvision.transforms.ToTensor():下载好的数据一般是numpy格式&＃xff0c;转换成Tensor
# torchvision.transforms.Normalisze((0.1307,), (0.3081,))&＃xff1a;正则化过程&＃xff0c;为了让数据更好的在0的附近均匀的分布
# 上面一行可注释掉&＃xff1a;但是性能会差到百分之70&＃xff0c;加上是百分之80&＃xff0c;更加方便神经网络去优化train_loader &＃61; torch.utils.data.DataLoader( # 加载训练集torchvision.datasets.MNIST(&＃39;mnist_data&＃39;, train&＃61;True, download&＃61;True,transform&＃61;torchvision.transforms.Compose([torchvision.transforms.ToTensor(),# torchvision.transforms.Normalize(# (0.1307,), (0.3081,))])),batch_size&＃61;batch_size, shuffle&＃61;True)
# batch_size&＃61;batch_size&＃xff1a;表示一次加载多少张图片
# shuffle &＃61; True 加载的时候做一个随机的打散test_loader &＃61; torch.utils.data.DataLoader( # 加载测试集torchvision.datasets.MNIST(&＃39;mnist_data/&＃39;, train&＃61;False, download&＃61;True,transform&＃61;torchvision.transforms.Compose([torchvision.transforms.ToTensor(),torchvision.transforms.Normalize((0.1307,), (0.3081,)) # 均值是0.1307&＃xff0c;标准差是0.3081&＃xff0c;# 这些系数都是数据集提供方计算好的数据])),batch_size&＃61;batch_size, shuffle&＃61;False) # 测试集不用打散x, y &＃61; next(iter(train_loader))
print(x.shape, y.shape, x.min(), x.max())
# plot_image(x, y, &＃39;image_sample&＃39;)class Net(nn.Module):def __init__(self): # 初始化函数super(Net, self).__init__()# 新建三层 xw&＃43;b是一层self.fc1 &＃61; nn.Linear(28*28, 256) # 这里的256是随机决定&＃xff0c;小维度是这样的&＃xff0c;经验self.fc2 &＃61; nn.Linear(256, 64)self.fc3 &＃61; nn.Linear(64, 10) # 28*28&＃61;784是输入&＃xff0c; 10是10种分类&＃xff0c;这两个是固定的。 256和64是经验决定def forward(self, x):# h1 &＃61; relu(xw&＃43;b) x: [b, 1, 28, 28]x &＃61; F.relu(self.fc1(x))# h2 &＃61; relu(h1w2&＃43;b2)x &＃61; F.relu(self.fc2(x))# h3 &＃61; h2w3&＃43;b3 最后一层加不加激活函数取决于具体的任务&＃xff0c;输出是输出概率值x &＃61; self.fc3(x) # 分类问题一般是softmax &＃43; mean squre error均方差 &＃xff0c;简单起见直接使用softmaxreturn xnet &＃61; Net() # 完成一个实例化# net.parameters(): 会帮我们拿到权值 [w1, b1, w2, b2, w3, b3]
# momentum: 动量&＃xff0c;帮助更好的优化的一个策略&＃xff0c;后面会讲
# lv: 学习率
optimizer &＃61; optim.SGD(net.parameters(), lr&＃61;0.01, momentum&＃61;0.9) # 梯度下降的优化器train_loss &＃61; [] # &＃64;&＃64;&＃64;1for epoch in range(3): # 对整个数据集迭代3遍for batch_idx, (x, y) in enumerate(train_loader): # 对整个数据集迭代一次# 这里是对一个batch迭代一次&＃xff0c;一次batch 512张图片# print(x.shape, y.shape) 输入 torch.Size([512, 1, 28, 28]) 输出 torch.Size([512])# x: [b, 1, 28, 28], y: [512]# 需要把输入tensor[b, 1, 28, 28] -> 打平为下面[b, feature]# [b, 1, 28, 28] &＃61;> [b, 784]# x.view 参考&＃xff1a;https://blog.csdn.net/zjc910997316/article/details/93472186x &＃61; x.view(x.size(0), 28*28) # x.size(0)表示batch 512 (512, 1, 28, 28) -> (512, 748)# &＃61;> [b, 10]out &＃61; net(x) # 经过了class Net(nn.Module):# [b, 10]y_onehot &＃61; one_hot(y)# loss &＃61; mse(out, y_onehot) mse 是 均方差 mean squre errorloss &＃61; F.mse_loss(out, y_onehot) # todo 1&＃xff1a;计算out与y_onehot之间的均方差&＃xff0c;得到lossoptimizer.zero_grad() # 先对梯度进行清零loss.backward() # todo 2&＃xff1a;梯度计算过程&＃xff0c;计算梯度# w&＃39; &＃61; w - lr*grad learn rate学习率optimizer.step() # todo 3&＃xff1a;更新权值train_loss.append(loss.item()) # &＃64;&＃64;&＃64;2if batch_idx % 10 &＃61;&＃61; 0: # 每隔10个batch打印一下print(epoch, batch_idx, loss.item()) # 第几个大循环&＃xff08;一共3个&＃xff09;&＃xff0c; 第多少批次eg:10 20 30 , loss显示plot_curve(train_loss) # &＃64;&＃64;&＃64;3
# we get optimal [w1, b1, w2, b2, w3, b3]# 下面用测试集来进行测试
total_correct &＃61; 0
# x: [b, 1, 28, 28]
for x, y in test_loader:x &＃61; x.view(x.size(0), 28*28)out &＃61; net(x)# out: [b, 10] &＃61;> pred:[b]pred &＃61; out.argmax(dim&＃61;1) # 取得[b, 10]的10个值的最大值所在位置的索引correct &＃61; pred.eq(y).sum().float().item() # 当前batch中与y标签等&＃xff0c;也就是预测对的总个数合计,item()取出它的数值total_correct &＃43;&＃61; correct# ------------后面是本节新加入部分------------
total_num &＃61; len(test_loader.dataset)
acc &＃61; total_correct / total_num
print(&＃39;test acc:&＃39;, acc) # test acc: 0.7799x, y &＃61; next(iter(test_loader)) # 取一个batch,查看预测结果
out &＃61; net(x.view(x.size(0), 28*28))
pred &＃61; out.argmax(dim&＃61;1) # 取得[b, 10]的10个值的最大值所在位置的索引
plot_image(x, pred, &＃39;test&＃39;)


1 有迭代过程&＃xff0c;有correct结果 0.7862

2 有loss图

3 有取其中多个图作展示&＃xff0c;一个错误

4 改进办法

1 增加一层

2 最后一层的输出可以使用softmax

参考&＃xff1a;https://blog.csdn.net/gaoyueace/article/details/79027081

3 loss使用的是均方差mean squre error &＃xff0c; 可以改成交叉熵The cross entropy

参考&＃xff1a;https://blog.csdn.net/gaoyueace/article/details/79027081

4 修改学习率