简单的深度神经网络实现——使用PyTorch

使用的数据集是MNIST，预期可以达到98%左右的准确率。

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

1.配置库和配置参数

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

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

2.加载MNIST数据

#加载MNIST数据
train_dataset=dsets.MNIST(root='./data',#数据保持的位置
                          train=True,#训练集
                          transform=transforms.ToTensor(),
                          download=True)
#将一个取值范围是【0,255】的PIL.Image转化成取值范围是【0,1.0】的torch.FloatTensor
test_dataset=dsets.MNIST(root='./data',
                         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模型

#创建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.训练流程

#训练流程
#Loss and Optimizer 定义loss和optimizer
criterion=nn.CrossEntropyLoss()
optimizer=torch.optim.Adam(net.parameters(),lr=learning_rate)

#train the model 开始训练
for epoch in range(num_epoches):
    for i,(images,labels) in enumerate(train_loader):#批处理
        #convert torch tensor to Variable
        images=Variable(images.view(-1,28*28))
        labels=Variable(labels)

        #forward+backward+optimize
        optimizer.zero_grad()#zero the gradient buffer梯度清零，以免影响其他batch
        outputs=net(images)#前向传播
        loss=criterion(outputs,labels)#loss
        loss.backward()#后向传播，计算梯度
        optimizer.step()#梯度更新

        if(i+1)%100==0:
            print('Epoch [%d/%d],Step[%d,%d],Loss:%.4f'%(epoch+1,num_epoches,i+1,len(train_dataset)//batch_size,loss.item()))

6.在测试集测试识别率

#Test the model,在测试集上验证模型
correct=0
total=0
for images,labels in test_loader:#test set批处理
    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 thr 10000 test iamges:%d %%'%(100*correct/total))