簡單的深度神經網絡實現——使用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))