工具方法和一些设置#

这里有一个帮助显示图片的方法和解决图片不显示问题的设置。

1
### 一些工具方法
2
import matplotlib.pyplot as plt
3
import numpy as np
4

5
# 如果不加则会出现如下错误，且不会显示图片
6
# Error #15: Initializing libiomp5md.dll...
7
import os
8

9
os.environ['KMP_DUPLICATE_LIB_OK'] = 'TRUE'
10

11
def imshow(img):
12
    """
13
    展示图片
14

15
    :param img:
16
    """
17

18
    # 去标准化
19
    img = img / 2 + 0.5
20
    npImg = img.numpy()
21
    # 切换维度
22
    plt.imshow(np.transpose(npImg, (1, 2, 0)))
23

24
    # 展示图片
25
    plt.show()

创建模型#

模型结果如图：

请添加图片描述

由于CIFAR10数据为彩色图片，因此第一层卷积 $conv1$ 将输入设置为 3图像通道。

1
import torch.nn as nn
2
import torch.nn.functional as F
3

4
class Net(nn.Module):
5
    def __init__(self):
6
        super(Net, self).__init__()
7

8
        # 因为输入为彩色图片，因此输入设置为3通道图像
9
        self.conv1 = nn.Conv2d(3, 6, 5)
10
        self.conv2 = nn.Conv2d(6, 16, 5)
11
        self.pool = nn.MaxPool2d(2, 2)
12
        self.fc1 = nn.Linear(16 * 5 * 5, 120)
13
        self.fc2 = nn.Linear(120, 84)
14
        self.fc3 = nn.Linear(84, 10)
15

16
    def forward(self, x):
17
        x = self.pool(F.relu(self.conv1(x)))
18
        x = self.pool(F.relu(self.conv2(x)))
19
        x = x.view(-1, 16 * 5 * 5)
20
        x = F.relu(self.fc1(x))
21
        x = F.relu(self.fc2(x))
22
        x = self.fc3(x)
23
        return x

导入CIFAR10数据#

导入数据并对数据进行归一化，便于模型学习。

1
import torch.utils.data
2
import torchvision.datasets
3
import torchvision.transforms as transforms
4

5
def load_data():
6
    """
7
    载入数据并转换为 DataLoader
8

9
    :return: trainloader, testloader
10
    """
11

12
    # 设置数据读取操作
13
    transform = transforms.Compose([
14
        # 导入为 Tensor
15
        transforms.ToTensor(),
16
        # 进行归一化操作，使数据范围变为[-1, 1]
17
        transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))
18
    ])
19

20
    # 导入CIFAR10训练集
21
    trainset = torchvision.datasets.CIFAR10(
22
        root='./data',  # 导入数据路径
23
        train=True,  # 导入数据是否为训练集
24
        download=True,  # 若未发现数据是否进行下载
25
        transform=transform  # 对数据进行处理
26
    )
27

28
    # 将训练集变为数据加载器，便于数据拿取
29
    trainloader = torch.utils.data.DataLoader(
30
        trainset,  # 源数据
31
        batch_size=4,  # 批大小
32
        shuffle=True,  # 是否打乱
33
        # num_workers=2 # 设置为2会报 [Errno 32] Broken pipe错误
34
        num_workers=0  # 工作进程数
35
    )
36

37
    # 导入测试集
38
    testset = torchvision.datasets.CIFAR10(
39
        root='./data', train=False, download=True, transform=transform
40
    )
41
    testloader = torch.utils.data.DataLoader(
42
        testset, batch_size=4, shuffle=False, num_workers=2
43
    )
44

45
    # 定义类名
46
    classes = ('plane', 'car', 'bird', 'cat',
47
               'deer', 'dog', 'frog', 'horse', 'ship', 'truck')
48
    return trainloader, testloader, classes

训练模型#

使用交叉熵损失和随机梯度下降训练模型。

1
import torch.optim as optim
2

3

4
def train(trainloader, _iter=2, lr=0.001):
5
    """
6
    训练
7

8
    :param trainloader:
9
    :return:net
10
    """
11

12
    # 实例化模型
13
    net = Net()
14

15
    # 指定损失函数为交叉熵
16
    loss_function = nn.CrossEntropyLoss()
17

18
    # 绑定优化器
19
    optimizer = optim.SGD(net.parameters(), lr=lr, momentum=0.9)
20

21
    # 记录每一步的损失
22
    losses = []
23

24
    # 开始训练
25
    for epoch in range(_iter):
26
        running_loss = 0
27
        for i, data in enumerate(trainloader, 0):
28
            # 获取输入
29
            inputs, labels = data
30

31
            # 清除累计梯度
32
            optimizer.zero_grad()
33

34
            # 正向传播
35
            outputs = net(inputs)
36

37
            # 计算损失
38
            loss = loss_function(outputs, labels)
39

40
            # 反向传播
41
            loss.backward()
42

43
            # 梯度下降
44
            optimizer.step()
45

46
            # 累加损失
47
            running_loss += loss.item()
48

49
            # 打印状态信息
50
            if i % 2000 == 1999:
51
                # 每2000批次打印一次
52
                print('[%d, %5d] loss: %.3f' %
53
                      (epoch + 1, i + 1, running_loss / 2000))
54
                # 记录损失
55
                losses.append(running_loss / 2000)
56
                # 重置损失
57
                running_loss = 0
58

59
    print('Finished Training')
60

61
    # 画出损失折线图
62
    plt.plot(list(range(len(losses))), losses)
63
    plt.show()
64
    return net

测试样例模型#

使用训练后的模型对测试集的数据进行预测。

1
def test(net, testloader, classes):
2
    """
3
    测试模型
4

5
    :param net:
6
    :param testloader:
7
    :param classes:
8
    :return:
9
    """
10

11
    # 加载数据
12
    dataiter = iter(testloader)
13
    images, labels = dataiter.next()
14

15
    # 显示图片
16
    # torchvision.utils.make_grid 将多张图片拼成一张
17
    imshow(torchvision.utils.make_grid(images))
18

19
    # 输出正确分类
20
    print('正确分类：', ' '.join([classes[i] for i in labels]))
21

22
    # 预测
23
    outputs = net(images)
24
    print('预测分类：', ' '.join([classes[i] for i in outputs.argmax(dim=1)]))

测试集总体评估#

在测试集上对模型总体效率进行评估。

1
def eval(net, testloader):
2
    # 记录正确个数
3
    correct = 0
4
    # 记录所有样例数
5
    total = 0
6

7
    for data in testloader:
8
        # 预测数据
9
        imgs, labels = data
10
        outputs = net(imgs)
11

12
        # 利用 argmax 来获得最大预测的索引
13
        preds = outputs.argmax(dim=1)
14

15
        # 记录数量和正确情况
16
        total += labels.size(0)
17
        correct += (preds == labels).sum()
18

19
    print('在整个测试集上的正确率为：%d %%' % (100 * correct / total))

对每个类进行评估#

对模型在每个类的识别能力进行评估。

1
def eval_for_each_class(net, testloader, classes):
2
    # 记录每个类的正确数和总数
3
    class_correct = list(0 for i in range(len(classes)))
4
    class_total = list(0 for i in range(len(classes)))
5

6
    for data in testloader:
7
        # 预测数据
8
        imgs, labels = data
9
        outputs = net(imgs)
10
        preds = outputs.argmax(dim=1)
11
        c = (preds == labels)
12

13
        # 记录数据和正确情况
14
        for index, label in enumerate(labels):
15
            class_correct[label] += c[index].item()
16
            class_total[label] += 1
17

18
    for i, c in enumerate(classes):
19
        print('%5s 类的正确率为：%2d %%' %
20
              (c, 100 * class_correct[i] / class_total[i]))

测试代码#

用于走完训练和测试流程。

1
if __name__ == '__main__':
2
    trainloader, testloader, classes = load_data()
3
    final_net = train(trainloader)
4
    test(final_net, testloader, classes)
5
    eval(final_net, testloader)
6
    eval_for_each_class(final_net, testloader, classes)

结果展示#

训练损失曲线#

在这里插入图片描述

可以看出后面的线条已经较为平缓，损失函数已经开始收敛。

测试样例模型结果#

1
正确分类： cat ship ship plane
2
预测分类： cat ship ship ship

可以看出有3个样例预测正确，1个样例预测错误。

测试集总体评估结果#

1
在整个测试集上的正确率为：56 %

各类评估结果#

1
plane 类的正确率为：64 %
2
  car 类的正确率为：58 %
3
 bird 类的正确率为：38 %
4
  cat 类的正确率为：25 %
5
 deer 类的正确率为：51 %
6
  dog 类的正确率为：43 %
7
 frog 类的正确率为：74 %
8
horse 类的正确率为：62 %
9
 ship 类的正确率为：80 %
10
truck 类的正确率为：63 %

总结#

由上面的各项结果可以看出，此次训练的LetNet模型准确率远低于现在的模型。这是由于LetNet模型是结构较为简单经典模型，且只进行了简单的训练。

虽然结果并不理想，但通过这次练习了解到了用pytorch进行训练的基本流程和实现。

完整代码#

1
### 一些工具方法
2
import matplotlib.pyplot as plt
3
import numpy as np
4

5
# 如果不加则会出现如下错误，且不会显示图片
6
# Error #15: Initializing libiomp5md.dll...
7
import os
8

9
os.environ['KMP_DUPLICATE_LIB_OK'] = 'TRUE'
10

11
#
12

13
def imshow(img):
14
    """
15
    展示图片
16

17
    :param img:
18
    """
19

20
    # 去标准化
21
    img = img / 2 + 0.5
22
    npImg = img.numpy()
23
    # 切换维度
24
    plt.imshow(np.transpose(npImg, (1, 2, 0)))
25

26
    # 展示图片
27
    plt.show()
28

29
###
30

31
### 1、创建模型
32
import torch.nn as nn
33
import torch.nn.functional as F
34

35
class Net(nn.Module):
36
    def __init__(self):
37
        super(Net, self).__init__()
38

39
        # 因为输入为彩色图片，因此输入设置为3通道图像
40
        self.conv1 = nn.Conv2d(3, 6, 5)
41
        self.conv2 = nn.Conv2d(6, 16, 5)
42
        self.pool = nn.MaxPool2d(2, 2)
43
        self.fc1 = nn.Linear(16 * 5 * 5, 120)
44
        self.fc2 = nn.Linear(120, 84)
45
        self.fc3 = nn.Linear(84, 10)
46

47
    def forward(self, x):
48
        x = self.pool(F.relu(self.conv1(x)))
49
        x = self.pool(F.relu(self.conv2(x)))
50
        x = x.view(-1, 16 * 5 * 5)
51
        x = F.relu(self.fc1(x))
52
        x = F.relu(self.fc2(x))
53
        x = self.fc3(x)
54
        return x
55

56
### 2、导入数据
57
import torch.utils.data
58
import torchvision.datasets
59
import torchvision.transforms as transforms
60

61
def load_data():
62
    """
63
    载入数据并转换为 DataLoader
64

65
    :return: trainloader, testloader
66
    """
67

68
    # 设置数据读取操作
69
    transform = transforms.Compose([
70
        # 导入为 Tensor
71
        transforms.ToTensor(),
72
        # 进行归一化操作，使数据范围变为[-1, 1]
73
        transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))
74
    ])
75

76
    # 导入CIFAR10训练集
77
    trainset = torchvision.datasets.CIFAR10(
78
        root='./data',  # 导入数据路径
79
        train=True,  # 导入数据是否为训练集
80
        download=True,  # 若未发现数据是否进行下载
81
        transform=transform  # 对数据进行处理
82
    )
83

84
    # 将训练集变为数据加载器，便于数据拿取
85
    trainloader = torch.utils.data.DataLoader(
86
        trainset,  # 源数据
87
        batch_size=4,  # 批大小
88
        shuffle=True,  # 是否打乱
89
        # num_workers=2 # 设置为2会报 [Errno 32] Broken pipe错误
90
        num_workers=0  # 工作进程数
91
    )
92

93
    # 导入测试集
94
    testset = torchvision.datasets.CIFAR10(
95
        root='./data', train=False, download=True, transform=transform
96
    )
97
    testloader = torch.utils.data.DataLoader(
98
        testset, batch_size=4, shuffle=False, num_workers=2
99
    )
100

101
    # 定义类名
102
    classes = ('plane', 'car', 'bird', 'cat',
103
               'deer', 'dog', 'frog', 'horse', 'ship', 'truck')
104
    return trainloader, testloader, classes
105

106
### 3、开始训练
107
import torch.optim as optim
108

109
def train(trainloader, _iter=2, lr=0.001):
110
    """
111
    训练
112

113
    :param trainloader:
114
    :return:net
115
    """
116

117
    # 实例化模型
118
    net = Net()
119

120
    # 指定损失函数为交叉熵
121
    loss_function = nn.CrossEntropyLoss()
122

123
    # 绑定优化器
124
    optimizer = optim.SGD(net.parameters(), lr=lr, momentum=0.9)
125

126
    # 记录每一步的损失
127
    losses = []
128

129
    # 开始训练
130
    for epoch in range(_iter):
131
        running_loss = 0
132
        for i, data in enumerate(trainloader, 0):
133
            # 获取输入
134
            inputs, labels = data
135

136
            # 清除累计梯度
137
            optimizer.zero_grad()
138

139
            # 正向传播
140
            outputs = net(inputs)
141

142
            # 计算损失
143
            loss = loss_function(outputs, labels)
144

145
            # 反向传播
146
            loss.backward()
147

148
            # 梯度下降
149
            optimizer.step()
150

151
            # 累加损失
152
            running_loss += loss.item()
153

154
            # 打印状态信息
155
            if i % 2000 == 1999:
156
                # 每2000批次打印一次
157
                print('[%d, %5d] loss: %.3f' %
158
                      (epoch + 1, i + 1, running_loss / 2000))
159
                # 记录损失
160
                losses.append(running_loss / 2000)
161
                # 重置损失
162
                running_loss = 0
163

164
    print('Finished Training')
165

166
    # 画出损失折线图
167
    plt.plot(list(range(len(losses))), losses)
168
    plt.show()
169
    return net
170

171
### 4、测试模型
172
def test(net, testloader, classes):
173
    """
174
    测试模型
175

176
    :param net:
177
    :param testloader:
178
    :param classes:
179
    :return:
180
    """
181

182
    # 加载数据
183
    dataiter = iter(testloader)
184
    images, labels = dataiter.next()
185

186
    # 显示图片
187
    # torchvision.utils.make_grid 将多张图片拼成一张
188
    imshow(torchvision.utils.make_grid(images))
189

190
    # 输出正确分类
191
    print('正确分类：', ' '.join([classes[i] for i in labels]))
192

193
    # 预测
194
    outputs = net(images)
195
    print('预测分类：', ' '.join([classes[i] for i in outputs.argmax(dim=1)]))
196

197
### 5、评估整个测试集
198
def eval(net, testloader):
199
    # 记录正确个数
200
    correct = 0
201
    # 记录所有样例数
202
    total = 0
203

204
    for data in testloader:
205
        # 预测数据
206
        imgs, labels = data
207
        outputs = net(imgs)
208

209
        # 利用 argmax 来获得最大预测的索引
210
        preds = outputs.argmax(dim=1)
211

212
        # 记录数量和正确情况
213
        total += labels.size(0)
214
        correct += (preds == labels).sum()
215

216
    print('在整个测试集上的正确率为：%d %%' % (100 * correct / total))
217

218
### 6、对每个类进行评估
219
def eval_for_each_class(net, testloader, classes):
220
    # 记录每个类的正确数和总数
221
    class_correct = list(0 for i in range(len(classes)))
222
    class_total = list(0 for i in range(len(classes)))
223

224
    for data in testloader:
225
        # 预测数据
226
        imgs, labels = data
227
        outputs = net(imgs)
228
        preds = outputs.argmax(dim=1)
229
        c = (preds == labels)
230

231
        # 记录数据和正确情况
232
        for index, label in enumerate(labels):
233
            class_correct[label] += c[index].item()
234
            class_total[label] += 1
235

236
    for i, c in enumerate(classes):
237
        print('%5s 类的正确率为：%2d %%' %
238
              (c, 100 * class_correct[i] / class_total[i]))
239

240
if __name__ == '__main__':
241
    trainloader, testloader, classes = load_data()
242
    final_net = train(trainloader)
243
    test(final_net, testloader, classes)
244
    eval(final_net, testloader)
245
    eval_for_each_class(final_net, testloader, classes)

原文链接：CSDN