基于PyTorch利用全连接神经网络识别MNIST手写数字

from torchvision import datasets, transforms
from torch import nn, optim
from torch.utils.data import DataLoader
import torch
from torch.autograd import Variable

# step1：定义超参数，并进行初始化
batch_size = 64
learn_rate = 0.001
num_epoches = 10000

# step2: 建立带有激励函数和批标准化函数的网络
class batch_net(nn.Module):
    def __init__(self, in_dim, n_hiddle_1, n_hiddle_2, out_dim):
        super(batch_net, self).__init__()
        self.layer1 = nn.Sequential(nn.Linear(in_dim, n_hiddle_1), nn.BatchNorm1d(n_hiddle_1), nn.ReLU(True))
        self.layer2 = nn.Sequential(nn.Linear(n_hiddle_1, n_hiddle_2), nn.BatchNorm1d(n_hiddle_2), nn.ReLU(True))
        self.layer3 = nn.Sequential(nn.Linear(n_hiddle_2, out_dim))
    def forward(self, x):
        x = self.layer1(x)
        x = self.layer2(x)
        x = self.layer3(x)
        return x

# step3：对数据进行标准化预处理
"""
    这里主要使用两个函数，一个是transforms.ToTensor(),将图片转换成pyTorch中的Tensor对象，并且进行归一化（0-1之间）处理；
    另一个是transforms.Normalize()进行标准化处理，他有两个参数，分别是均值和标准差，如transforms.Normalize([0.5], [0.5])
    表示将数据减去0.5后，再除以0.5，这样将数据转化到-1到1之间，注意，因为MNIST数据集输入的图片是灰度图片，所以只有1个通道，如果
    是输入的图片是财社的图片，则有三个通道
    然后用transforms.Compose()函数将各种预处理的操作组合在一起
"""
data_tf = transforms.Compose([
    transforms.ToTensor(),
    transforms.Normalize([0.5], [0.5])
])

# step4:导入MNIST数据集
"""
   （1）root='./data'程序会自动在当前目录下建立一个文件夹data
   （2）train=True表示数据集作为训练接。train=False表示数据集作为测试集
   （3） transforms=data_tf吧PIL Image对象转化为Tensor对象
   （4）download=True表示数据从Internet上下载，否则数据不从internet上下载
   （5）shuffle=True表示表示每次迭代数据打乱，False反之
"""
train_dataset = datasets.MNIST(root='./data', train=True, transform=data_tf, download=True)
test_dataset = datasets.MNIST(root='./data', train=False, transform=data_tf)
train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True)
test_loader = DataLoader(test_dataset, batch_size=batch_size, shuffle=False)

# step5:导入神经网络模型， 定义损失函数和优化函数
model = batch_net(28*28, 300, 100, 10) # 28*28表示图片大小、300,100表示隐藏层的数量，最后的10表示10个类别
# 定义损失函数
criterion = nn.CrossEntropyLoss()
# 定义一个优化函数
optimizer = optim.SGD(model.parameters(), lr=learn_rate)

# step6:训练模型
epoch = 0
for data in train_loader:
    img, label = data
    img = img.view(img.size(0), -1) # x = x.view(x.size(0), -1)  这句话的出现就是为了将前面多维度的tensor展平成一维。
    # 下面这段程序以后会经常使用到，表示如果有GPU，则使用
    if torch.cuda.is_available():
        img = img.cuda()
        label = label.cuda()
    else:
        img = Variable(img)
        label = Variable(label)
    out = model(img)
    loss = criterion(out, label)
    print_loss = loss.data.item() # 官方文档解释.item()用法是：一个元素张量可以用x.item()得到元素值，我理解的就是一个是张量，一个是元素。
    optimizer.zero_grad() # optimizer.zero_grad()意思是把梯度置零，也就是把loss关于weight的导数变成0.
    # 对于下面两个操作我是把它理解成一种梯度下降法，
    loss.backward()
    optimizer.step()
    epoch+=1
    if epoch%10==0:
        print('epoch:{},loss:{:.4f}'.format(epoch, loss.data.item()))

if __name__ =="__main()__":
    model.eval()
    eval_loss = 0
    eval_acc = 0
    for data in test_loader:
        img, label = data
        img = img.view(img.size(0), -1)
        if torch.cuda.is_available():
            img = img.cuda()
            label = label.cuda()
        out = model(img)
        loss = criterion(out, label)
        eval_loss+=loss.data.item()*label.size(0)
        """
         在分类问题中，通常需要使用max()函数对softmax函数的输出值进行操作，求出预测值索引，然后与标签进行比对，计算准确率。
         下面讲解一下torch.max()函数的输入及输出值都是什么，便于我们理解该函数。
         torch.max(input, dim) 函数
         输入:
        input是softmax函数输出的一个tensor
        dim是max函数索引的维度0/1，0是每列的最大值，1是每行的最大值
        输出:
        函数会返回两个tensor，第一个tensor是每行的最大值；第二个tensor是每行最大值的索引。
        """
        _,pred = torch.max(out, 1)
        num_corred = (pred==label).sum()
        eval_acc+=num_corred.item()
        print('Test:{:.6f}', 'Acc:{:.6f}'.format(
            eval_loss/(len(test_dataset)),
            eval_acc/(len(test_dataset))
        ))

结果如下所示：