MINIST测试集的正确率为100%？

非科班跨考计算机，导师的方向是深度学习，于是跟着b站一个视频敲了一遍MINIST训练的代码，发现最后测试的结果居然是正确率100%？而且loss下降的速度也非常的慢。这肯定是哪里出问题了，找了半天还是没有发现问题。训练集和测试集都是用torch的MINIST类下在同一个根目录里了，到底是哪里出问题了，完整代码贴在下面了

import numpy as np
import matplotlib.pyplot as plt
from torch.utils.data import Dataset,DataLoader
from torchvision import transforms
from torchvision import datasets
import torch.nn.functional as F
import torch.optim as optim

batch_size=64
transform=transforms.Compose([transforms.ToTensor(),transforms.Normalize((0.1307,),(0.3081,))])

train_dataset=datasets.MNIST(root='D:\pitorch_lx\PythonApplication2',train=True,download=True,transform=transform)
train_loader=DataLoader(dataset=train_dataset,batch_size=batch_size,shuffle=True)

test_dataset=datasets.MNIST(root='D:\pitorch_lx\PythonApplication2',train=False,download=True,transform=transform)
test_loader=DataLoader(dataset=test_dataset,batch_size=batch_size,shuffle=False)




class Net(torch.nn.Module):
    def __init__(self):
        super(Net,self).__init__()
        self.Linear1=torch.nn.Linear(784,512)
        self.Linear2=torch.nn.Linear(512,256)
        self.Linear3=torch.nn.Linear(256,128)
        self.Linear4=torch.nn.Linear(128,64)
        self.Linear5=torch.nn.Linear(64,10)
        
        

    def forward(self,x):
        x=x.view(-1,784)
        x=F.relu(self.Linear1(x))
        x=F.relu(self.Linear2(x))
        x=F.relu(self.Linear3(x))
        x=F.relu(self.Linear4(x))
        return self.Linear5(x)


model=Net()

criterion=torch.nn.CrossEntropyLoss()
optimizer=optim.SGD(model.parameters(),lr=0.01,momentum=0.5)

def train(epoch):
    running_loss=0.0
    for batch_idx,data in enumerate(train_loader,0):
        inputs,target=data
        optimizer.zero_grad()
        outputs=model(inputs)
        loss=criterion(outputs,target)
        loss.backward()
        optimizer.step()

        running_loss+=loss.item()
        if batch_idx%300==299:
            print('[%d %5d] loss:%.3f'%(epoch+1,batch_idx+1,running_loss/300))
            running_loss=0.0

def test():
    corrtect=0
    total=0
    with torch.no_grad():
        for data in test_loader:
            images,labels=data
        outputs=model(images)
        _,predicted=torch.max(outputs.data,dim=1)
        total+=labels.size(0)
        corrtect+=(predicted==labels).sum().item()
        print('Accuracy on test set:%d %%'%(100*corrtect/total))
        
    

if __name__=='__main__':
    for epoch in range(10):
        train(epoch)
        test()

代码有错误

def test():
    corrtect = 0
    total = 0
    allimages = torch.empty(0, 1, 28, 28)
    alllabels = torch.empty(0)
    with torch.no_grad():
        for data in test_loader:
            images, labels = data
            allimages = torch.cat((allimages, images), 0)
            alllabels = torch.cat((alllabels, labels), 0)
        outputs = model(allimages)
        _, predicted = torch.max(outputs.data, dim=1)
        total += alllabels.size(0)
        corrtect += (predicted == alllabels).sum().item()
        print('Accuracy on test set:%d %%' % (100 * corrtect / total))

你的写法只测试了10000%64=16个，所以是100%。

1官方的算法是Lenet网络精度是99.32
2你这个精度是100%没什么问题
3你这个网络都是全连接层进行实现的，效果比前面存在几个卷积层更好，
4可以试试吧网络换成Lenet精度就下来了
吗网络结构如下
nn.Conv2d(1, 6, 5, padding=2)
nn.Conv2d(6, 16, 5)
nn.Linear(1655, 120)
nn.Linear(120, 84)
nn.Linear(84, 10)
5我也是今年上岸研究生可以加我一起讨论哈哈哈