pytorch实现手写数字识别 | MNIST数据集（全连接神经网络）

import torch
from torchvision import transforms  # 对图像进行原始的数据处理的工具
from torchvision import datasets  # 获取数据
from torch.utils.data import DataLoader  # 加载数据
import torch.nn.functional as F  # 与全连接层中的relu激活函数 有关
import torch.optim as optim  # 与优化器有关
# prepare dataset
batch_size = 64
# GPU对2的幂次的batch可以发挥更佳的性能，因此设置成16、32、64、128…时往往要比设置为整10、整100的倍数时表现更优
# 在神经网络训练时，常常需要采用批输入数据的方法，为此需要设定每次输入的批数据大小batch_size
transform = transforms.Compose([  # 处理图像
    transforms.ToTensor(),  # Convert the PIL Image to Tensor
    transforms.Normalize((0.1307,), (0.3081,))  # 归一化；0.1307为均值，0.3081为标准差
])
train_dataset = datasets.MNIST(root='./dataset/mnist/', train=True, download=True, transform=transform)  
# download=True表示自动下载MNIST数据集(建议科学上网，不然速度很慢，而且可能下载中断)
train_loader = DataLoader(train_dataset, shuffle=True, batch_size=batch_size)
test_dataset = datasets.MNIST(root='./dataset/mnist/', train=False, download=True, transform=transform)
test_loader = DataLoader(test_dataset, shuffle=False, batch_size=batch_size)
class Net(torch.nn.Module):  # design model using class
    def __init__(self):
        super(Net, self).__init__()
        self.l1 = torch.nn.Linear(784, 512)
        self.l2 = torch.nn.Linear(512, 256)
        self.l3 = torch.nn.Linear(256, 128)
        self.l4 = torch.nn.Linear(128, 64)
        self.l5 = torch.nn.Linear(64, 10)
    def forward(self, x):
        x = x.view(-1, 784)  # -1其实就是自动获取mini_batch
        # Tensor.view(*shape) → Tensor：Returns a new tensor with the same data as the self tensor but of a different shape.
        x = F.relu(self.l1(x))
        x = F.relu(self.l2(x))
        x = F.relu(self.l3(x))
        x = F.relu(self.l4(x))
        return self.l5(x)  # 最后一层不做激活，不进行非线性变换
model = Net()
# construct loss and optimizer
criterion = torch.nn.CrossEntropyLoss()  # 构建损失函数
optimizer = optim.SGD(model.parameters(), lr=0.01, momentum=0.5)
# lr (float) – learning rate学习率   ；   momentum (float, optional) – momentum factor (default: 0)动量因子 (默认: 0)
# training cycle forward, backward, update
def train(epoch):
    running_loss = 0.0
    for batch_idx, data in enumerate(train_loader, 0):
        # 获得一个批次的数据和标签
        inputs, target = data
        optimizer.zero_grad()
        # 获得模型预测结果(64, 10)
        outputs = model(inputs)
        # 交叉熵代价函数outputs(64,10),target（64）
        loss = criterion(outputs, target)
        loss.backward()
        optimizer.step()
        running_loss += loss.item()
        if batch_idx % 300 == 299:  # batch_idx最大值为937；937*64=59968 意味着丢弃了部分的样本
            print('[%d, %5d] loss: %.3f' % (epoch + 1, batch_idx + 1, running_loss / 300))
            # 注：在python中，通过使用%，实现格式化字符串的目的；%d 有符号整数(十进制)
            running_loss = 0.0
def test():
    correct = 0  # 正确预测的数量
    total = 0  # 总数量
    with torch.no_grad():  # 测试的时候不需要计算梯度（避免产生计算图）
        for data in test_loader:
            images, labels = data
            outputs = model(images)
            _, predicted = torch.max(outputs.data, dim=1)  # dim = 1 列是第0个维度，行是第1个维度
            total += labels.size(0)
            correct += (predicted == labels).sum().item()  # 张量之间的比较运算
    print('accuracy on test set: %d %% ' % (100 * correct / total))
if __name__ == '__main__':
    for epoch in range(10):
        train(epoch)
        test()

Downloading http://yann.lecun.com/exdb/mnist/train-images-idx3-ubyte.gz to ./dataset/mnist/MNIST\raw\train-images-idx3-ubyte.gz
100.1%
Extracting ./dataset/mnist/MNIST\raw\train-images-idx3-ubyte.gz to ./dataset/mnist/MNIST\raw
Downloading http://yann.lecun.com/exdb/mnist/train-labels-idx1-ubyte.gz to ./dataset/mnist/MNIST\raw\train-labels-idx1-ubyte.gz
113.5%
Extracting ./dataset/mnist/MNIST\raw\train-labels-idx1-ubyte.gz to ./dataset/mnist/MNIST\raw
Downloading http://yann.lecun.com/exdb/mnist/t10k-images-idx3-ubyte.gz to ./dataset/mnist/MNIST\raw\t10k-images-idx3-ubyte.gz
100.4%
Extracting ./dataset/mnist/MNIST\raw\t10k-images-idx3-ubyte.gz to ./dataset/mnist/MNIST\raw
Downloading http://yann.lecun.com/exdb/mnist/t10k-labels-idx1-ubyte.gz to ./dataset/mnist/MNIST\raw\t10k-labels-idx1-ubyte.gz
180.4%
Extracting ./dataset/mnist/MNIST\raw\t10k-labels-idx1-ubyte.gz to ./dataset/mnist/MNIST\raw
Processing...
Done!
[1,   300] loss: 2.146
[1,   600] loss: 0.746
[1,   900] loss: 0.412
accuracy on test set: 89 % 
[2,   300] loss: 0.311
[2,   600] loss: 0.264
[2,   900] loss: 0.231
accuracy on test set: 94 % 
[3,   300] loss: 0.192
[3,   600] loss: 0.166
[3,   900] loss: 0.153
accuracy on test set: 96 % 
[4,   300] loss: 0.132
[4,   600] loss: 0.122
[4,   900] loss: 0.120
accuracy on test set: 96 % 
[5,   300] loss: 0.100
[5,   600] loss: 0.090
[5,   900] loss: 0.098
accuracy on test set: 96 % 
[6,   300] loss: 0.077
[6,   600] loss: 0.078
[6,   900] loss: 0.076
accuracy on test set: 97 % 
[7,   300] loss: 0.061
[7,   600] loss: 0.066
[7,   900] loss: 0.064
accuracy on test set: 97 % 
[8,   300] loss: 0.049
[8,   600] loss: 0.051
[8,   900] loss: 0.055
accuracy on test set: 97 % 
[9,   300] loss: 0.040
[9,   600] loss: 0.045
[9,   900] loss: 0.040
accuracy on test set: 97 % 
[10,   300] loss: 0.033
[10,   600] loss: 0.035
[10,   900] loss: 0.034
accuracy on test set: 97 %