1. import numpy as np
    2. import torch
    3. # 调入pytorch内置的mnist数据
    4. from torchvision.datasets import mnist
    5. # 导入预处理模块
    6. import torchvision.transforms as transforms
    7. from torch.utils.data import DataLoader
    8. # 导入nn以及优化器
    9. import torch.nn.functional as F
    10. import torch.optim as optim
    11. from torch import nn
    12. import matplotlib.pyplot as plt
    14. # 当前程序为残差的手写数字识别
    16. # 定义一些超参数
    17. train_batch_size = 32
    18. test_batch_size = 64
    19. learning_rate = 0.01
    20. num_epoches = 10
    21. lr = 0.01
    22. momentum = 0.5
    23. # 下载数据并且进行数据预处理
    24. # 定义预处理函数，这些函数依次放在Compose函数中
    25. # 其中transforms.Compose用来把他们组合在一起，Normalize([0.5], [0.5])用来进行归一化
    26. # 因图像是灰色的，只有一个通道，所以只有一个数字，如果是三个通道，就需要三个数字
    27. transform = transforms.Compose([transforms.ToTensor(), transforms.Normalize([0.5], [0.5])])
    28. # 下载数据，并对数据进行预处理
    29. train_dataset = mnist.MNIST('./data', train=True, transform=transform, download=False)
    30. test_dataset = mnist.MNIST('./data', train=False, transform=transform)
    31. # dataloader是一个可迭代对象，可以使用迭代器一样使用。
    32. train_loader = DataLoader(train_dataset, batch_size=train_batch_size, shuffle=True)
    33. test_loader = DataLoader(test_dataset, batch_size=test_batch_size, shuffle=False)
    34. # 可视化数据源
    35. examples = enumerate(test_loader)
    36. batch_idx, (example_data, example_targets) = next(examples)
    37. fig = plt.figure()
    40. # 用来展示图片
    41. # for i in range(6):
    42. #     plt.subplot(2, 3, i + 1)
    43. #     plt.tight_layout()
    44. #     plt.imshow(example_data[i][0], cmap='gray', interpolation='none')
    45. #     plt.title("Ground Truth: {}".format(example_targets[i]))
    46. #     plt.xticks([])
    47. #     plt.yticks([])
    48. #     plt.show()
    50. class ResidualBlock(nn.Module):
    51.     def __init__(self, channels):
    52.         super(ResidualBlock, self).__init__()
    53.         self.channels = channels
    54.         self.conv1 = torch.nn.Conv2d(channels, channels, kernel_size=3, padding=1)
    55.         self.conv2 = torch.nn.Conv2d(channels, channels, kernel_size=3, padding=1)
    57.     def forward(self, x):
    58.         y = F.relu(self.conv1(x))
    59.         y = self.conv2(y)
    60.         return F.relu(x + y)
    63. class Net(nn.Module):
    64.     def __init__(self):
    65.         super(Net, self).__init__()
    66.         self.conv1 = nn.Conv2d(1, 10, 5)
    67.         self.mp = nn.MaxPool2d(2)
    68.         self.rblock1 = ResidualBlock(10)
    69.         self.conv2 = nn.Conv2d(10, 20, 3)
    70.         self.rblock2 = ResidualBlock(20)
    71.         self.flatten1 = nn.Flatten()
    72.         self.linear1 = nn.Linear(500, 10)
    74.     def forward(self, x):
    75.         x = F.relu(self.mp(self.conv1(x)))
    76.         x = self.rblock1(x)
    77.         x = F.relu(self.mp(self.conv2(x)))
    78.         x = self.rblock2(x)
    79.         x = self.flatten1(x)
    80.         x = self.linear1(x)
    81.         x = F.log_softmax(x, dim=1)
    82.         return x
    85. device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
    86. # 实例化网络
    87. model = Net()
    88. model.to(device)
    90. # 定义损失函数和优化器
    91. criterion = nn.CrossEntropyLoss();
    92. optimizer = optim.SGD(model.parameters(), lr=lr, momentum=momentum)
    94. # 训练模型
    95. losses = []
    96. acces = []
    97. eval_losses = []
    98. eval_acces = []
    99. for epoch in range(num_epoches):
    100.     train_loss = 0
    101.     train_acc = 0
    102.     model.train()
    103.     # 动态修改学习率
    104.     if epoch % 5 == 0:
    105.         optimizer.param_groups[0]['lr'] *= 0.1
    106.     for batch_idx, (img, label) in enumerate(train_loader):
    107.         # print(img.shape)
    108.         # torch.Size([64, 1, 28, 28])
    109.         img = img.to(device)
    110.         label = label.to(device)
    111.         # 这里把图像压成了一维的
    112.         # img = img.view(img.size(0), -1)
    113.         # 前向传播
    114.         out = model(img)
    115.         loss = criterion(out, label)
    116.         # 反向传播
    117.         optimizer.zero_grad()
    118.         loss.backward()
    119.         optimizer.step()
    120.         # 记录误差
    121.         train_loss += loss.item()
    122.         # 计算分类的准确率
    123.         _, pred = out.max(1)
    124.         num_correct = (pred == label).sum().item()
    125.         acc = num_correct / img.shape[0]
    126.         train_acc += acc
    128.     losses.append(train_loss / len(train_loader))
    129.     acces.append(train_acc / len(train_loader))
    130.     #     在测试集上检验效果
    131.     eval_loss = 0
    132.     eval_acc = 0
    133.     #     将模型改为预测模式
    134.     model.eval()
    135.     for img, label in test_loader:
    136.         img = img.to(device)
    137.         label = label.to(device)
    138.         out = model(img)
    139.         loss = criterion(out, label)
    140.         #         记录误差
    141.         eval_loss += loss.item()
    142.         #         记录准确率
    143.         _, pred = out.max(1)
    144.         num_correct = (pred == label).sum().item()
    145.         acc = num_correct / img.shape[0]
    146.         eval_acc += acc
    148.     eval_losses.append(eval_loss / len(test_loader))
    149.     eval_acces.append(eval_acc / len(test_loader))
    150.     print('epoch: {}, Train Loss: {:.4f}, Train Acc: {:.4f}, Test Loss: {:.4f}, Test Acc: {:.4f}'
    151.           .format(epoch, train_loss / len(train_loader), train_acc / len(train_loader),
    152.                   eval_loss / len(test_loader), eval_acc / len(test_loader)))
    154. plt.title('train loss')
    155. plt.plot(np.arange(len(losses)), losses)
    156. plt.legend(['Train Loss'], loc='upper right')
    157. plt.show()