手写数字MINIST识别

# 1.制作数据集
import matplotlib.pyplot as plt
import torch
import torch.nn as nn
from torch.utils.data import DataLoader
from torchvision import datasets
from torchvision import transforms

# 数据集转换参数
transform = transforms.Compose([transforms.ToTensor(), transforms.Normalize(0.1307, 0.3081)])
# 下载训练集与测试集
train_Data = datasets.MNIST('D:/PyCharm/minist/', train=True
                            , download=True, transform=transform)
test_Data = datasets.MNIST('D:/PyCharm/minist/', train=False
                           , download=True, transform=transform)
# 批次加载器
train_loader = DataLoader(train_Data, batch_size=128, shuffle=True)
test_loader = DataLoader(test_Data, batch_size=64, shuffle=False)


# 搭建神经网络
class DNN(nn.Module):
    def __init__(self):
        super(DNN, self).__init__()
        self.net = nn.Sequential(
            #28X28=784
            nn.Linear(784, 512),
            nn.ReLU(),
            nn.Linear(512, 256),
            nn.ReLU(),
            nn.Linear(256, 128),
            nn.ReLU(),
            nn.Linear(128, 64),
            nn.ReLU(),
            nn.Linear(64, 10)
            #数字0-9一共10个
        )

    def forward(self, x):
        y = self.net(x)
        return y


model = DNN().to('cuda:0')
print(model)

#训练网络
#损失函数的选择
loss_fn=nn.CrossEntropyLoss() #自带softmax激活函数
#优化算法的选择
learning_rate=0.01
optimizer=torch.optim.SGD(model.parameters(),lr=learning_rate,momentum=0.9)
#momentum动量，它使梯度下降算法有了力与惯性

epochs=5
losses=[]
for epoch in range(epochs):
    #获取小批次的x与y
    for(x,y) in train_loader:
        #将图像展平成784维向量
        x=x.view(x.size(0),-1)
        x,y=x.to('cuda:0'),y.to('cuda:0')
        Pred=model(x)
        loss=loss_fn(Pred,y)
        losses.append(loss.item())
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()

Fig=plt.figure()
plt.plot(range(len(losses)),losses)
plt.show()

#测试网络
correct=0
total=0
for(x,y) in test_loader:
    x=x.view(x.size(0),-1)
    x,y=x.to('cuda:0'),y.to('cuda:0')
    Pred=model(x)
    _,predicted=torch.max(Pred.data,dim=1)
    #a, b = torch.max(Pred.data, dim=1)的意思是，找出 Pred 每一行里的最大值，
    #数值赋给 a，所处位置赋给 b。
    correct+=torch.sum((predicted==y))
    total+=y.size(0)
print(f"测试集进准度：{100*correct/total}%")