[PyTorch]——MNIST数据集的简单深度神经网络实现

1.题目描述：

使用Pytorch实现一个简单的深度神经网络，使用的数据集是MNIST,预期结果可以达到98%左右的准确率。

该神经网络由1个输入层、1个全连接层结构的隐含层和1个输出层构建。

2.数据集的下载

手写数字, 训练集数量60000, 测试集数量10000. 参考: http://yann.lecun.com/exdb/mnist/

在AI Studio下载，放在mnist_data\MNIST\raw目录即可

3.具体实现过程

（1）配置库和配置参数

import torch
import torch.nn as nn
import torchvision.datasets as dsets
import torchvision.transforms as transforms
from torch.autograd import Variable

#Hyper Parameters 配置参数
torch.manual_seed(1) #设置随机数种子，确保结果可重复
input_size = 784
hidden_size = 500
num_classes = 10
num_epochs = 15 #训练次数
batch_size = 100 #批处理大小
learnint_rate = 0.001 #学习率

（2）加载MNIST DataSet 下载训练集MNIST手写数字训练集

train_dataset = dsets.MNIST(root = "./dataset",   #数据保存的位置
                            train = True,           #训练集
                            transform = transforms.ToTensor(),
                            #一个取值范围是[0, 255]的PIL.Image  转换为取值范围是[0, 1.0]的torch.FloadTensor
                            download=True) #下载数据
test_dataset = dsets.MNIST(root = "./dataset",
                            train = False ,# 测试集
                            transform = transforms.ToTensor())

（3）数据的批处理

#Data Loader  (Input Pipeline)
#数据的批处理，尺寸大小为batch_size
#在训练集中，shuffle必须设置为True  ，表示次序是随机的
train_loader = torch.utils.data.DataLoader(dataset = train_dataset,
                                           batch_size = batch_size,
                                           shuffle= True)

test_loader = torch.utils.data.DataLoader(dataset = test_dataset,
                                          batch_size = batch_size,
                                          shuffle = False)

（4）创建DNN模型

#Neural Network Model (1 hidden layer)  定义神经网络模型
class Net(nn.Module):
    def __init__(self,input_size, hidden_size, num_classes):
        super(Net,self).__init__()
        self.fc1 = nn.Linear(input_size,hidden_size)
        self.relu = nn.ReLU()
        self.fc2 = nn.Linear(hidden_size,num_classes)

    def forward(self,x):
        out = self.fc1(x)
        out = self.relu(out)
        out = self.fc2(out)
        return out

net = Net(input_size, hidden_size, num_classes)
#打印模型，呈现网络结构
print(net)

打印模型结果：

（5）训练流程

"""开始训练：将 images、labels都用Variable包起来，然后放入模型中计算输出，最后计算Loss和正确率"""
#Loss and Optimizer 定义Loss 和Optimizer
criterion = nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(net.parameters(),lr = learnint_rate)

#Train the Model 开始训练
for epoch in range(num_epochs):
    for i,(images,labels) in enumerate(train_loader):
        images=Variable(images.view(-1,28*28))
        labels=Variable(labels)

        optimizer.zero_grad()
        outputs=net(images)
        loss=criterion(outputs,labels)

        loss.backward()
        optimizer.step()
    print(epoch,"loss:",loss.item())

（6）在测试集测试识别率

#Test the Model,测试集上验证模型
correct = 0
total = 0
#test set批处理
for images,labels in test_loader:
    #Convert torch tensor to Variable
    images = Variable(images.view(-1, 28 * 28))
    outputs = net(images)
    #预测结果
    _,predicted = torch.max(outputs.data, 1)
    #正确结果
    total += labels.size(0)
    #正确结果总数
    correct += (predicted == labels).sum()
    print("Accuracy of the network on the 10000 test images: %d %%" % (100 * correct / total))

4.结果