04、pytorch训练一个cifar10的分类器

东方耀

pytorch训练一个cifar10的分类器
上一讲中已经看到如何去定义一个神经网络，计算损失值和更新网络的权重。 你现在可能在想下一步。


关于数据？
一般情况下处理图像、文本、音频和视频数据时，可以使用标准的Python包来加载数据到一个numpy数组中。 然后把这个数组转换成 torch.*Tensor。


图像可以使用 Pillow, OpenCV
音频可以使用 scipy, librosa
文本可以使用原始Python和Cython来加载，或者使用 NLTK或 SpaCy 处理
特别的，对于图像任务，我们创建了一个包 torchvision，它包含了处理一些基本图像数据集的方法。这些数据集包括 Imagenet, CIFAR10, MNIST 等。除了数据加载以外，torchvision 还包含了图像转换器， torchvision.datasets 和 torch.utils.data.DataLoader。


torchvision包不仅提供了巨大的便利，也避免了代码的重复。


在这个教程中，我们使用CIFAR10数据集，它有如下10个类别 ：‘airplane’, ‘automobile’, ‘bird’, ‘cat’, ‘deer’, ‘dog’, ‘frog’, ‘horse’, ‘ship’, ‘truck’。CIFAR-10的图像都是 3x32x32大小的，即，3颜色通道，32x32像素

1. # -*- coding: utf-8 -*-
   
2. __author__ = u'东方耀 微信：dfy_88888'
   
3. __date__ = '2020/4/9 下午5:20'
   
4. __product__ = 'PyCharm'
   
5. __filename__ = 'dfy02'
   
6. 
   
7. 
   
8. # 训练一个图像分类器
   
9. # 依次按照下列顺序进行：
   
10. #
    
11. # 1、使用torchvision加载和归一化CIFAR10训练集和测试集
    
12. # 2、定义一个卷积神经网络
    
13. # 3、定义损失函数
    
14. # 4、在训练集上训练网络
    
15. # 5、在测试集上测试网络
    
16. 
    
17. 
    
18. # 1、读取和归一化 CIFAR10
    
19. # 使用torchvision可以非常容易地加载CIFAR10。
    
20. import torch
    
21. import torchvision
    
22. import torchvision.transforms as transforms
    
23. # torchvision的输出是[0,1]的PILImage图像，我们把它转换为归一化范围为[-1, 1]的张量。
    
24. 
    
25. transform = transforms.Compose(
    
26.     [transforms.ToTensor(),
    
27.      transforms.Normalize(mean=(0.5, 0.5, 0.5), std=(0.5, 0.5, 0.5))])
    
28. 
    
29. trainset = torchvision.datasets.CIFAR10(root='./data', train=True,
    
30.                                         download=True, transform=transform)
    
31. trainloader = torch.utils.data.DataLoader(trainset, batch_size=4,
    
32.                                           shuffle=True, num_workers=2)
    
33. # 下载数据 https://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz
    
34. testset = torchvision.datasets.CIFAR10(root='./data', train=False,
    
35.                                        download=True, transform=transform)
    
36. testloader = torch.utils.data.DataLoader(testset, batch_size=4,
    
37.                                          shuffle=False, num_workers=2)
    
38. 
    
39. classes = ('plane', 'car', 'bird', 'cat',
    
40.            'deer', 'dog', 'frog', 'horse', 'ship', 'truck')
    
41. 
    
42. import matplotlib.pyplot as plt
    
43. import numpy as np
    
44. 
    
45. # 展示图像的函数
    
46. 
    
47. 
    
48. def imshow(img):
    
49.     # [-1, 1] to [0,1]
    
50.     img = img / 2 + 0.5     # unnormalize
    
51.     npimg = img.numpy()
    
52.     # CHW ---> HWC
    
53.     plt.imshow(np.transpose(npimg, (1, 2, 0)))
    
54. 
    
55. 
    
56. # 获取随机数据
    
57. dataiter = iter(trainloader)  # 迭代器
    
58. images, labels = dataiter.next()
    
59. # [4, 3, 32, 32]
    
60. print(images.size())
    
61. # [4,]
    
62. print('标签数据：', labels.size(), labels.numpy())
    
63. 
    
64. # 展示图像
    
65. imshow(torchvision.utils.make_grid(images))
    
66. # 显示图像标签
    
67. print(' '.join('%5s' % classes[labels[j]] for j in range(4)))
    
68. 
    
69. # plt.show()
    
70. 
    
71. # 2、定义一个卷积神经网络
    
72. import torch.nn as nn
    
73. import torch.nn.functional as F
    
74. 
    
75. 
    
76. class Net(nn.Module):
    
77.     def __init__(self):
    
78.         super(Net, self).__init__()
    
79.         # 二维卷积 5*5*3*6
    
80.         self.conv1 = nn.Conv2d(3, 6, 5)
    
81.         self.pool = nn.MaxPool2d(2, 2)
    
82.         self.conv2 = nn.Conv2d(6, 16, 5)
    
83.         self.fc1 = nn.Linear(16 * 5 * 5, 120)
    
84.         self.fc2 = nn.Linear(120, 84)
    
85.         self.fc3 = nn.Linear(84, 10)
    
86. 
    
87.     def forward(self, x):
    
88.         # 输入的x的size = [4, 3, 32, 32]
    
89.         x = self.pool(F.relu(self.conv1(x)))
    
90.         x = self.pool(F.relu(self.conv2(x)))
    
91.         x = x.view(-1, 16 * 5 * 5)
    
92.         x = F.relu(self.fc1(x))
    
93.         x = F.relu(self.fc2(x))
    
94.         x = self.fc3(x)
    
95.         # x = F.softmax(x, dim=1)
    
96.         return x
    
97. 
    
98. 
    
99. net = Net()
    
100. print('net的结构：', net)
     
101. params = list(net.parameters())
     
102. print(len(params))
     
103. print("conv1's .weight size=", params[0].size())
     
104. for i in range(len(params)):
     
105.     print('layer-%d的权重size=' % i, params[i].size())
     
106. 
     
107. # 3、定义损失函数和优化器
     
108. # 我们使用交叉熵作为损失函数，使用带动量的随机梯度下降。
     
109. import torch.optim as optim
     
110. 
     
111. criterion = nn.CrossEntropyLoss()
     
112. optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9)
     
113. 
     
114. # 4、训练网路
     
115. # 我们只需在数据迭代器上循环，将数据输入给网络，并优化。
     
116. for epoch in range(2):  # 多批次循环
     
117. 
     
118.     running_loss = 0.0
     
119.     print('开始第%d轮的训练！' % epoch)
     
120.     for i, data in enumerate(trainloader, 0):
     
121.         # 获取输入
     
122.         inputs, labels = data
     
123.         # torch.Size([4, 3, 32, 32])
     
124.         # print('inputs.size=', inputs.size())
     
125. 
     
126.         # 梯度置0
     
127.         optimizer.zero_grad()
     
128. 
     
129.         # 正向传播，反向传播，优化
     
130.         outputs = net(inputs)
     
131.         loss = criterion(outputs, labels)
     
132.         # 反向传播 计算梯度
     
133.         loss.backward()
     
134.         # 优化器更新网络参数
     
135.         optimizer.step()
     
136. 
     
137.         # 打印状态信息
     
138.         # 如果你有只有一个元素的张量，使用.item()来得到Python数据类型的数值
     
139.         running_loss += loss.item()
     
140.         if i % 2000 == 1999:    # 每2000批次打印一次
     
141.             print('[第%d轮, %5d] loss: %.4f' %
     
142.                   (epoch, i + 1, running_loss / 2000))
     
143.             running_loss = 0.0
     
144. 
     
145. print('Finished Training')
     
146. 
     
147. # 5、在测试集上测试网络
     
148. # 我们在整个训练集上进行了2轮训练，但是我们需要检查网络是否从数据集中学习到有用的东西。
     
149. # 通过预测神经网络输出的类别标签与实际情况标签进行对比来进行检测。
     
150. # 如果预测正确，我们把该样本添加到正确预测列表。
     
151. 
     
152. # 第一步，显示测试集中的图片并熟悉图片内容
     
153. dataiter = iter(testloader)
     
154. images, labels = dataiter.next()
     
155. 
     
156. # 显示图片
     
157. imshow(torchvision.utils.make_grid(images))
     
158. print('GroundTruth: ', ' '.join('%5s' % classes[labels[j]] for j in range(4)))
     
159. 
     
160. # 让我们看看神经网络认为以上图片是什么。
     
161. outputs = net(images)
     
162. # 4*10
     
163. # outputs.data
     
164. _, predicted = torch.max(outputs, 1)
     
165. 
     
166. print('Predicted: ', ' '.join('%5s' % classes[predicted[j]]
     
167.                               for j in range(4)))
     
168. 
     
169. # 接下来让看看网络在整个测试集上的结果如何。
     
170. correct = 0
     
171. total = 0
     
172. with torch.no_grad():
     
173.     for data in testloader:
     
174.         images, labels = data
     
175.         outputs = net(images)
     
176.         _, predicted = torch.max(outputs.data, 1)
     
177.         total += labels.size(0)
     
178.         correct += (predicted == labels).sum().item()
     
179. 
     
180. # Accuracy of the network on the 10000 test images: 54 %
     
181. print('Accuracy of the network on the 10000 test images: %d %%' % (
     
182.     100 * correct / total))
     
183. 
     
184. # 结果看起来不错，至少比随机选择要好，随机选择的正确率为10%。 似乎网络学习到了一些东西。
     
185. #
     
186. # 在识别哪一个类的时候好，哪一个不好呢？
     
187. class_correct = list(0. for i in range(10))
     
188. class_total = list(0. for i in range(10))
     
189. with torch.no_grad():
     
190.     for data in testloader:
     
191.         images, labels = data
     
192.         outputs = net(images)
     
193.         _, predicted = torch.max(outputs, 1)
     
194.         c = (predicted == labels).squeeze()
     
195.         for i in range(4):
     
196.             label = labels[i]
     
197.             class_correct[label] += c[i].item()
     
198.             class_total[label] += 1
     
199. 
     
200. 
     
201. for i in range(10):
     
202.     print('Accuracy of %5s : %2d %%' % (
     
203.         classes[i], 100 * class_correct[i] / class_total[i]))
     
204. 
     
205. 
     
206. 
     

复制代码

我们如何在GPU上运行神经网络呢？

在GPU上训练
把一个神经网络移动到GPU上训练就像把一个Tensor转换GPU上一样简单。
并且这个操作会递归遍历有所模块，并将其参数和缓冲区转换为CUDA张量。


device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
print(device)

这些方法将递归遍历所有模块并将模块的参数和缓冲区 转换成CUDA张量：
net.to(device)

记住：inputs 和 targets 也要转换。
inputs, labels = inputs.to(device), labels.to(device)

为什么我们没注意到GPU的速度提升很多？那是因为网络非常的小。
# cpu上训练的耗时： 106.1030011177063 秒
# gpu上的耗时：65.4867947101593 秒

1. # -*- coding: utf-8 -*-
   
2. __author__ = u'东方耀 微信：dfy_88888'
   
3. __date__ = '2020/4/9 下午5:20'
   
4. __product__ = 'PyCharm'
   
5. __filename__ = 'dfy02'
   
6. 
   
7. 
   
8. # 训练一个图像分类器
   
9. # 依次按照下列顺序进行：
   
10. #
    
11. # 1、使用torchvision加载和归一化CIFAR10训练集和测试集
    
12. # 2、定义一个卷积神经网络
    
13. # 3、定义损失函数
    
14. # 4、在训练集上训练网络
    
15. # 5、在测试集上测试网络
    
16. 
    
17. 
    
18. # 1、读取和归一化 CIFAR10
    
19. # 使用torchvision可以非常容易地加载CIFAR10。
    
20. import torch
    
21. import torchvision
    
22. import torchvision.transforms as transforms
    
23. # torchvision的输出是[0,1]的PILImage图像，我们把它转换为归一化范围为[-1, 1]的张量。
    
24. 
    
25. transform = transforms.Compose(
    
26.     [transforms.ToTensor(),
    
27.      transforms.Normalize(mean=(0.5, 0.5, 0.5), std=(0.5, 0.5, 0.5))])
    
28. 
    
29. trainset = torchvision.datasets.CIFAR10(root='./data', train=True,
    
30.                                         download=True, transform=transform)
    
31. trainloader = torch.utils.data.DataLoader(trainset, batch_size=4,
    
32.                                           shuffle=True, num_workers=2)
    
33. # 下载数据 https://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz
    
34. testset = torchvision.datasets.CIFAR10(root='./data', train=False,
    
35.                                        download=True, transform=transform)
    
36. testloader = torch.utils.data.DataLoader(testset, batch_size=4,
    
37.                                          shuffle=False, num_workers=2)
    
38. 
    
39. classes = ('plane', 'car', 'bird', 'cat',
    
40.            'deer', 'dog', 'frog', 'horse', 'ship', 'truck')
    
41. 
    
42. import matplotlib.pyplot as plt
    
43. import numpy as np
    
44. 
    
45. # 展示图像的函数
    
46. 
    
47. 
    
48. def imshow(img):
    
49.     # [-1, 1] to [0,1]
    
50.     img = img / 2 + 0.5     # unnormalize
    
51.     npimg = img.numpy()
    
52.     # CHW ---> HWC
    
53.     plt.imshow(np.transpose(npimg, (1, 2, 0)))
    
54. 
    
55. 
    
56. # 获取随机数据
    
57. dataiter = iter(trainloader)  # 迭代器
    
58. images, labels = dataiter.next()
    
59. # [4, 3, 32, 32]
    
60. print(images.size())
    
61. # [4,]
    
62. print('标签数据：', labels.size(), labels.numpy())
    
63. 
    
64. # 展示图像
    
65. imshow(torchvision.utils.make_grid(images))
    
66. # 显示图像标签
    
67. print(' '.join('%5s' % classes[labels[j]] for j in range(4)))
    
68. 
    
69. # plt.show()
    
70. 
    
71. # 2、定义一个卷积神经网络
    
72. import torch.nn as nn
    
73. import torch.nn.functional as F
    
74. 
    
75. 
    
76. class Net(nn.Module):
    
77.     def __init__(self):
    
78.         super(Net, self).__init__()
    
79.         # 二维卷积 5*5*3*6
    
80.         self.conv1 = nn.Conv2d(3, 6, 5)
    
81.         self.pool = nn.MaxPool2d(2, 2)
    
82.         self.conv2 = nn.Conv2d(6, 16, 5)
    
83.         self.fc1 = nn.Linear(16 * 5 * 5, 120)
    
84.         self.fc2 = nn.Linear(120, 84)
    
85.         self.fc3 = nn.Linear(84, 10)
    
86. 
    
87.     def forward(self, x):
    
88.         # 输入的x的size = [4, 3, 32, 32]
    
89.         x = self.pool(F.relu(self.conv1(x)))
    
90.         x = self.pool(F.relu(self.conv2(x)))
    
91.         x = x.view(-1, 16 * 5 * 5)
    
92.         x = F.relu(self.fc1(x))
    
93.         x = F.relu(self.fc2(x))
    
94.         x = self.fc3(x)
    
95.         # x = F.softmax(x, dim=1)
    
96.         return x
    
97. 
    
98. 
    
99. net = Net()
    
100. device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
     
101. print(device)
     
102. net.to(device)
     
103. print('net的结构：', net)
     
104. params = list(net.parameters())
     
105. print(len(params))
     
106. print("conv1's .weight size=", params[0].size())
     
107. for i in range(len(params)):
     
108.     print('layer-%d的权重size=' % i, params[i].size())
     
109. 
     
110. # 3、定义损失函数和优化器
     
111. # 我们使用交叉熵作为损失函数，使用带动量的随机梯度下降。
     
112. import torch.optim as optim
     
113. 
     
114. criterion = nn.CrossEntropyLoss()
     
115. optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9)
     
116. 
     
117. import time
     
118. start_time = time.time()
     
119. # 4、训练网路
     
120. # 我们只需在数据迭代器上循环，将数据输入给网络，并优化。
     
121. for epoch in range(2):  # 多批次循环
     
122. 
     
123.     running_loss = 0.0
     
124.     print('开始第%d轮的训练！' % epoch)
     
125.     for i, data in enumerate(trainloader, 0):
     
126.         # 获取输入
     
127.         inputs, labels = data
     
128.         # torch.Size([4, 3, 32, 32])
     
129.         # print('inputs.size=', inputs.size())
     
130.         # 记住：inputs 和 targets 也要转换
     
131.         inputs, labels = inputs.to(device), labels.to(device)
     
132. 
     
133.         # 梯度置0
     
134.         optimizer.zero_grad()
     
135. 
     
136.         # 正向传播，反向传播，优化
     
137.         outputs = net(inputs)
     
138.         loss = criterion(outputs, labels)
     
139.         # 反向传播 计算梯度
     
140.         loss.backward()
     
141.         # 优化器更新网络参数
     
142.         optimizer.step()
     
143. 
     
144.         # 打印状态信息
     
145.         # 如果你有只有一个元素的张量，使用.item()来得到Python数据类型的数值
     
146.         running_loss += loss.item()
     
147.         if i % 2000 == 1999:    # 每2000批次打印一次
     
148.             print('[第%d轮, %5d] loss: %.4f' %
     
149.                   (epoch, i + 1, running_loss / 2000))
     
150.             running_loss = 0.0
     
151. 
     
152. # cpu上训练的耗时： 106.1030011177063 秒
     
153. # gpu上的耗时：65.4867947101593 秒
     
154. print('Finished Training, 共耗时：', time.time() - start_time)
     
155. 
     
156. # 5、在测试集上测试网络
     
157. # 我们在整个训练集上进行了2轮训练，但是我们需要检查网络是否从数据集中学习到有用的东西。
     
158. # 通过预测神经网络输出的类别标签与实际情况标签进行对比来进行检测。
     
159. # 如果预测正确，我们把该样本添加到正确预测列表。
     
160. 
     
161. # 第一步，显示测试集中的图片并熟悉图片内容
     
162. dataiter = iter(testloader)
     
163. images, labels = dataiter.next()
     
164. 
     
165. # 显示图片
     
166. imshow(torchvision.utils.make_grid(images))
     
167. print('GroundTruth: ', ' '.join('%5s' % classes[labels[j]] for j in range(4)))
     
168. 
     
169. # 让我们看看神经网络认为以上图片是什么。
     
170. # RuntimeError: Input type (torch.FloatTensor)
     
171. # and weight type (torch.cuda.FloatTensor) should be the same
     
172. images = images.to(device)
     
173. outputs = net(images)
     
174. # 4*10
     
175. # outputs.data
     
176. _, predicted = torch.max(outputs, 1)
     
177. 
     
178. print('Predicted: ', ' '.join('%5s' % classes[predicted[j]]
     
179.                               for j in range(4)))
     
180. 
     
181. # 接下来让看看网络在整个测试集上的结果如何。
     
182. correct = 0
     
183. total = 0
     
184. with torch.no_grad():
     
185.     for data in testloader:
     
186.         images, labels = data
     
187.         images, labels = images.to(device), labels.to(device)
     
188.         outputs = net(images)
     
189.         _, predicted = torch.max(outputs.data, 1)
     
190.         total += labels.size(0)
     
191.         correct += (predicted == labels).sum().item()
     
192. 
     
193. # Accuracy of the network on the 10000 test images: 54 %
     
194. print('Accuracy of the network on the 10000 test images: %d %%' % (
     
195.     100 * correct / total))
     
196. 
     
197. # 结果看起来不错，至少比随机选择要好，随机选择的正确率为10%。 似乎网络学习到了一些东西。
     
198. #
     
199. # 在识别哪一个类的时候好，哪一个不好呢？
     
200. class_correct = list(0. for i in range(10))
     
201. class_total = list(0. for i in range(10))
     
202. with torch.no_grad():
     
203.     for data in testloader:
     
204.         images, labels = data
     
205.         images, labels = images.to(device), labels.to(device)
     
206.         outputs = net(images)
     
207.         _, predicted = torch.max(outputs, 1)
     
208.         c = (predicted == labels).squeeze()
     
209.         for i in range(4):
     
210.             label = labels[i]
     
211.             class_correct[label] += c[i].item()
     
212.             class_total[label] += 1
     
213. 
     
214. 
     
215. for i in range(10):
     
216.     print('Accuracy of %5s : %2d %%' % (
     
217.         classes[i], 100 * class_correct[i] / class_total[i]))
     
218. 
     
219. 
     
220. 
     

复制代码

东方耀

cifar-10-python.tar.gz的下载（官网非常慢， 我给出百度盘）：链接: https://pan.baidu.com/s/1W_F31q3olZO61O-p1F6ACA  密码: jn34

东方耀

设备间转换
一般情况下可以使用.cuda方法将tensor移动到gpu，这步操作需要cuda设备支持

1. cpu_a=torch.rand(4, 3)
   
2. cpu_a.type()
   
3. gpu_a=cpu_a.cuda()
   
4. gpu_a.type()
   
5. 使用.cpu方法将tensor移动到cpu
   
6. cpu_b=gpu_a.cpu()
   
7. cpu_b.type()

复制代码

如果我们有多GPU的情况，可以使用to方法来确定使用那个设备