基于PyTorch的BP神经网络的MNIST识别

实例环境使用PyTorch1.7,GPU/CPU，数据集为MNIST

步骤:

1. 利用PyTorch内置函数mnist下载数据
2. 利用torchvision对数据进行预处理，调用torch.utils建立一个数据迭代器
3. 可视化源数据
4. 利用torch.nn工具箱构建神经网络模型
5. 实例化模型，定义损失函数和优化器
6. 训练模型
7. 测试模型
8. 可视化结果

import  numpy as np
import torch
#导入pytorch内置的mnist数据
import os
os.environ['KMP_DUPLICATE_LIB_OK'] = 'TRUE'
from torchvision.datasets import  mnist
#导入预处理模块
import torchvision.transforms as transforms
from torch.utils.data import  DataLoader
#导入nn及优化器
import torch.nn.functional as F
import torch.optim as optim
from torch import nn

from tensorboardX import  SummaryWriter

#定义一些超参数
train_batch_size = 64
test_batch_size = 128
learning_rate = 0.01
num_epoches = 20

transform = transforms.Compose([transforms.ToTensor(),transforms.Normalize([0.5], [0.5])])

#定义预处理函数
transform = transforms.Compose([transforms.ToTensor(),transforms.Normalize([0.5], [0.5])])

#下载数据，并对数据进行预处理
train_dataset = mnist.MNIST(r'D:\Python\python_dataset\torch', train=True, transform=transform, download=True)
test_dataset = mnist.MNIST(r'D:\Python\python_dataset\torch', train=False, transform=transform)
#得到一个生成器
train_loader = DataLoader(train_dataset, batch_size=train_batch_size, shuffle=True)
test_loader = DataLoader(test_dataset, batch_size=test_batch_size, shuffle=False)

examples = enumerate(test_loader)
batch_idx,(example_data,example_targets) = next(examples)
print(train_dataset)
print(test_dataset)
print(examples)

print(example_data.shape)
print(example_targets.shape)
print(example_data[0][0].shape)

import matplotlib.pyplot as plt
examples = enumerate(test_loader)
batch_idx,(example_data,example_targets) = next(examples)

plt.figure()
for i in range(6):
    plt.subplot(2,3,i+1)
    plt.tight_layout()
    plt.imshow(example_data[i][0],cmap='gray',interpolation='none')
    plt.title("Ground Truth:{}".format(example_targets[i]))
    plt.xticks([])
    plt.yticks([])
plt.show()

#构建模型
class Net(nn.Module):
    def __init__(self,in_dim,n_hidden_1,n_hidden_2,out_dim):
        super(Net,self).__init__()
        self.layer1 = nn.Sequential(nn.Linear(in_dim,n_hidden_1),nn.BatchNorm1d(n_hidden_1))
        self.layer2 = nn.Sequential(nn.Linear(n_hidden_1,n_hidden_2),nn.BatchNorm1d(n_hidden_2))
        self.layer3 = nn.Sequential(nn.Linear(n_hidden_2,out_dim))

    def forward(self,x):
        x = F.relu(self.layer1(x))
        x = F.relu(self.layer2(x))
        x = self.layer3(x)
        return x

lr = 0.01
momentum = 0.9

#实例化模型
device = torch.device("cuda:0" if torch.cuda.is_available() else 'cpu')
model = Net(28*28,300,100,10)
model.to(device)

#定义损失函数和优化器

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

#模型训练
losses = []
accuracy = []
eval_losses = []
eval_accuracy = []
writer = SummaryWriter(log_dir='logs',comment='train-loss')

for epoch in range(num_epoches):
    train_loss = 0
    train_acc = 0
    model.train()
    #动态学习率
    if epoch%5==0:
        optimizer.param_groups[0]['lr']*=0.9
        print(optimizer.param_groups[0]['lr'])
    for img,label in train_loader:
        img = img.to(device)
        label = label.to(device)
        img = img.view(img.size(0),-1)
        #前向传播
        out = model(img)
        loss = criterion(out,label)
        #反向传播
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()
        #记录误差
        train_loss += loss.item()
        #保存loss的数据与epoch数值
        writer.add_scalar("Train",train_loss / len(train_loader),epoch)
        #计算分类的准确率
        _,pred = out.max(1)
        num_correct = (pred == label).sum().item()
        acc = num_correct / img.shape[0]
        train_acc += acc

    losses.append(train_loss / len(train_loader))
    accuracy.append(train_acc / len(train_loader))

    #测试集上检验效果
    eval_loss = 0
    eval_acc = 0
    #net.eval()#将模型改为预测模式
    model.eval()
    for img,label in test_loader:
        img = img.to(device)
        label = label.to(device)
        img = img.view(img.size(0),-1)
        out = model(img)
        loss = criterion(out,label)
        #记录误差
        eval_loss += loss.item()
        #记录准确率
        _,pred = out.max(1)
        num_correct = (pred==label).sum().item()
        acc = num_correct / img.shape[0]
        eval_acc += acc

    eval_losses.append(eval_loss / len(test_loader))
    eval_accuracy.append(eval_acc / len(test_loader))
    print('epoch: {}, Train Loss: {:.4f}, Train Acc: {:.4f}, Test Loss: {:.4f}, Test Acc: {:.4f}'
          .format(epoch, train_loss / len(train_loader), train_acc / len(train_loader),
                  eval_loss / len(test_loader), eval_acc / len(test_loader)))

plt.title("train loss")
plt.plot(np.arange(len(losses)),losses)
plt.legend(['Train Loss'],loc='upper right')
plt.show()

D:\Python\Anaconda\envs\pyG\python.exe D:/Python/pycharm/pycharm_code/Python_PyTorch/第三章/PyTorch神经网络工具箱.py
Dataset MNIST
    Number of datapoints: 60000
    Root location: D:\Python\python_dataset\torch
    Split: Train
    StandardTransform
Transform: Compose(
               ToTensor()
               Normalize(mean=[0.5], std=[0.5])
           )
Dataset MNIST
    Number of datapoints: 10000
    Root location: D:\Python\python_dataset\torch
    Split: Test
    StandardTransform
Transform: Compose(
               ToTensor()
               Normalize(mean=[0.5], std=[0.5])
           )
<enumerate object at 0x000001E3A80BFF98>
torch.Size([128, 1, 28, 28])
torch.Size([128])
torch.Size([28, 28])
0.009000000000000001
epoch: 0, Train Loss: 0.2251, Train Acc: 0.9360, Test Loss: 0.0913, Test Acc: 0.9729
epoch: 1, Train Loss: 0.0872, Train Acc: 0.9738, Test Loss: 0.0740, Test Acc: 0.9775
epoch: 2, Train Loss: 0.0563, Train Acc: 0.9831, Test Loss: 0.0646, Test Acc: 0.9812
epoch: 3, Train Loss: 0.0447, Train Acc: 0.9860, Test Loss: 0.0643, Test Acc: 0.9797
epoch: 4, Train Loss: 0.0334, Train Acc: 0.9899, Test Loss: 0.0635, Test Acc: 0.9799
0.008100000000000001
epoch: 5, Train Loss: 0.0239, Train Acc: 0.9931, Test Loss: 0.0558, Test Acc: 0.9835
epoch: 6, Train Loss: 0.0205, Train Acc: 0.9941, Test Loss: 0.0538, Test Acc: 0.9842
epoch: 7, Train Loss: 0.0164, Train Acc: 0.9952, Test Loss: 0.0576, Test Acc: 0.9828
epoch: 8, Train Loss: 0.0148, Train Acc: 0.9958, Test Loss: 0.0559, Test Acc: 0.9837
epoch: 9, Train Loss: 0.0114, Train Acc: 0.9971, Test Loss: 0.0546, Test Acc: 0.9836
0.007290000000000001
epoch: 10, Train Loss: 0.0092, Train Acc: 0.9974, Test Loss: 0.0555, Test Acc: 0.9832
epoch: 11, Train Loss: 0.0072, Train Acc: 0.9983, Test Loss: 0.0527, Test Acc: 0.9840
epoch: 12, Train Loss: 0.0064, Train Acc: 0.9985, Test Loss: 0.0509, Test Acc: 0.9847
epoch: 13, Train Loss: 0.0061, Train Acc: 0.9987, Test Loss: 0.0540, Test Acc: 0.9844
epoch: 14, Train Loss: 0.0047, Train Acc: 0.9990, Test Loss: 0.0577, Test Acc: 0.9835
0.006561000000000002
epoch: 15, Train Loss: 0.0056, Train Acc: 0.9985, Test Loss: 0.0522, Test Acc: 0.9839
epoch: 16, Train Loss: 0.0044, Train Acc: 0.9989, Test Loss: 0.0544, Test Acc: 0.9840
epoch: 17, Train Loss: 0.0038, Train Acc: 0.9992, Test Loss: 0.0549, Test Acc: 0.9840
epoch: 18, Train Loss: 0.0040, Train Acc: 0.9991, Test Loss: 0.0541, Test Acc: 0.9850
epoch: 19, Train Loss: 0.0031, Train Acc: 0.9994, Test Loss: 0.0547, Test Acc: 0.9852