度学习pytorch实战六：ResNet50网络图像分类篇自建花数据集图像分类（5类） ...

1.数据集简介、训练集与测试集分别
2.模子相干知识
3.model.py——定义ResNet50网络模子
4.train.py——加载数据集并训练，训练集盘算丧失值loss，测试集盘算accuracy，生存训练好的网络参数
5.predict.py——使用训练好的网络参数后，用自己找的图像举行分类测试
一、数据集简介

1.自建数据文件夹
起首确定这次分类种类，采用爬虫、官网数据集和自己照相的照片获取5类，新建个文件夹data，内里包含5个文件夹，文件夹名字取种类英文，每个文件夹照片数目最好一样多，五百多张以上。如我选了雏菊，蒲公英，玫瑰，向日葵，郁金香5类，如下图，每种类型有600~900张图像。如下图
花数据集下载链接https://storage.googleapis.com/download.tensorflow.org/example_images/flower_photos.tgz

2.分别训练集与测试集
这是分别数据集代码，同一目次下运，复制改文件夹路径。

1. import os
2. from shutil import copy
3. import random
6. def mkfile(file):
7.     if not os.path.exists(file):
8.         os.makedirs(file)
11. # 获取 photos 文件夹下除 .txt 文件以外所有文件夹名（即3种分类的类名）
12. file_path = 'data/flower_photos'
13. flower_class = [cla for cla in os.listdir(file_path) if ".txt" not in cla]
15. # 创建 训练集train 文件夹，并由3种类名在其目录下创建3个子目录
16. mkfile('flower_data/train')
17. for cla in flower_class:
18.     mkfile('flower_data/train/' + cla)
20. # 创建 验证集val 文件夹，并由3种类名在其目录下创建3个子目录
21. mkfile('flower_data/val')
22. for cla in flower_class:
23.     mkfile('flower_data/val/' + cla)
25. # 划分比例，训练集 : 验证集 = 9 : 1
26. split_rate = 0.1
28. # 遍历3种花的全部图像并按比例分成训练集和验证集
29. for cla in flower_class:
30.     cla_path = file_path + '/' + cla + '/'  # 某一类别动作的子目录
31.     images = os.listdir(cla_path)  # iamges 列表存储了该目录下所有图像的名称
32.     num = len(images)
33.     eval_index = random.sample(images, k=int(num * split_rate))  # 从images列表中随机抽取 k 个图像名称
34.     for index, image in enumerate(images):
35.         # eval_index 中保存验证集val的图像名称
36.         if image in eval_index:
37.             image_path = cla_path + image
38.             new_path = 'flower_data/val/' + cla
39.             copy(image_path, new_path)  # 将选中的图像复制到新路径
41.         # 其余的图像保存在训练集train中
42.         else:
43.             image_path = cla_path + image
44.             new_path = 'flower_data/train/' + cla
45.             copy(image_path, new_path)
46.         print("\r[{}] processing [{}/{}]".format(cla, index + 1, num), end="")  # processing bar
47.     print()
49. print("processing done!")

复制代码

二、模子相干知识

之前有文章先容模子，如果不清晰可以点下链接转过去学习。
深度学习卷积神经网络CNN之ResNet模子网络详解说明（超具体理论篇）

三、model.py——定义ResNet50网络模子

1. import torch.nn as nn
2. import torch
5. class BasicBlock(nn.Module):
6.     expansion = 1
8.     def __init__(self, in_channel, out_channel, stride=1, downsample=None, **kwargs):
9.         super(BasicBlock, self).__init__()
10.         self.conv1 = nn.Conv2d(in_channels=in_channel, out_channels=out_channel,
11.                                kernel_size=3, stride=stride, padding=1, bias=False)
12.         self.bn1 = nn.BatchNorm2d(out_channel)
13.         self.relu = nn.ReLU()
14.         self.conv2 = nn.Conv2d(in_channels=out_channel, out_channels=out_channel,
15.                                kernel_size=3, stride=1, padding=1, bias=False)
16.         self.bn2 = nn.BatchNorm2d(out_channel)
17.         self.downsample = downsample
19.     def forward(self, x):
20.         identity = x
21.         if self.downsample is not None:
22.             identity = self.downsample(x)
24.         out = self.conv1(x)
25.         out = self.bn1(out)
26.         out = self.relu(out)
28.         out = self.conv2(out)
29.         out = self.bn2(out)
31.         out += identity
32.         out = self.relu(out)
34.         return out
37. class Bottleneck(nn.Module):
38.     """
39.     注意：原论文中，在虚线残差结构的主分支上，第一个1x1卷积层的步距是2，第二个3x3卷积层步距是1。
40.     但在pytorch官方实现过程中是第一个1x1卷积层的步距是1，第二个3x3卷积层步距是2，
41.     这么做的好处是能够在top1上提升大概0.5%的准确率。
42.     可参考Resnet v1.5 https://ngc.nvidia.com/catalog/model-scripts/nvidia:resnet_50_v1_5_for_pytorch
43.     """
44.     expansion = 4
46.     def __init__(self, in_channel, out_channel, stride=1, downsample=None,
47.                  groups=1, width_per_group=64):
48.         super(Bottleneck, self).__init__()
50.         width = int(out_channel * (width_per_group / 64.)) * groups
52.         self.conv1 = nn.Conv2d(in_channels=in_channel, out_channels=width,
53.                                kernel_size=1, stride=1, bias=False)  # squeeze channels
54.         self.bn1 = nn.BatchNorm2d(width)
55.         # -----------------------------------------
56.         self.conv2 = nn.Conv2d(in_channels=width, out_channels=width, groups=groups,
57.                                kernel_size=3, stride=stride, bias=False, padding=1)
58.         self.bn2 = nn.BatchNorm2d(width)
59.         # -----------------------------------------
60.         self.conv3 = nn.Conv2d(in_channels=width, out_channels=out_channel*self.expansion,
61.                                kernel_size=1, stride=1, bias=False)  # unsqueeze channels
62.         self.bn3 = nn.BatchNorm2d(out_channel*self.expansion)
63.         self.relu = nn.ReLU(inplace=True)
64.         self.downsample = downsample
66.     def forward(self, x):
67.         identity = x
68.         if self.downsample is not None:
69.             identity = self.downsample(x)
71.         out = self.conv1(x)
72.         out = self.bn1(out)
73.         out = self.relu(out)
75.         out = self.conv2(out)
76.         out = self.bn2(out)
77.         out = self.relu(out)
79.         out = self.conv3(out)
80.         out = self.bn3(out)
82.         out += identity
83.         out = self.relu(out)
85.         return out
88. class ResNet(nn.Module):
90.     def __init__(self,
91.                  block,
92.                  blocks_num,
93.                  num_classes=1000,
94.                  include_top=True,
95.                  groups=1,
96.                  width_per_group=64):
97.         super(ResNet, self).__init__()
98.         self.include_top = include_top
99.         self.in_channel = 64
101.         self.groups = groups
102.         self.width_per_group = width_per_group
104.         self.conv1 = nn.Conv2d(3, self.in_channel, kernel_size=7, stride=2,
105.                                padding=3, bias=False)
106.         self.bn1 = nn.BatchNorm2d(self.in_channel)
107.         self.relu = nn.ReLU(inplace=True)
108.         self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)
109.         self.layer1 = self._make_layer(block, 64, blocks_num[0])
110.         self.layer2 = self._make_layer(block, 128, blocks_num[1], stride=2)
111.         self.layer3 = self._make_layer(block, 256, blocks_num[2], stride=2)
112.         self.layer4 = self._make_layer(block, 512, blocks_num[3], stride=2)
113.         if self.include_top:
114.             self.avgpool = nn.AdaptiveAvgPool2d((1, 1))  # output size = (1, 1)
115.             self.fc = nn.Linear(512 * block.expansion, num_classes)
117.         for m in self.modules():
118.             if isinstance(m, nn.Conv2d):
119.                 nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu')
121.     def _make_layer(self, block, channel, block_num, stride=1):
122.         downsample = None
123.         if stride != 1 or self.in_channel != channel * block.expansion:
124.             downsample = nn.Sequential(
125.                 nn.Conv2d(self.in_channel, channel * block.expansion, kernel_size=1, stride=stride, bias=False),
126.                 nn.BatchNorm2d(channel * block.expansion))
128.         layers = []
129.         layers.append(block(self.in_channel,
130.                             channel,
131.                             downsample=downsample,
132.                             stride=stride,
133.                             groups=self.groups,
134.                             width_per_group=self.width_per_group))
135.         self.in_channel = channel * block.expansion
137.         for _ in range(1, block_num):
138.             layers.append(block(self.in_channel,
139.                                 channel,
140.                                 groups=self.groups,
141.                                 width_per_group=self.width_per_group))
143.         return nn.Sequential(*layers)
145.     def forward(self, x):
146.         x = self.conv1(x)
147.         x = self.bn1(x)
148.         x = self.relu(x)
149.         x = self.maxpool(x)
151.         x = self.layer1(x)
152.         x = self.layer2(x)
153.         x = self.layer3(x)
154.         x = self.layer4(x)
156.         if self.include_top:
157.             x = self.avgpool(x)
158.             x = torch.flatten(x, 1)
159.             x = self.fc(x)
161.         return x
164. def resnet34(num_classes=1000, include_top=True):
165.     # https://download.pytorch.org/models/resnet34-333f7ec4.pth
166.     return ResNet(BasicBlock, [3, 4, 6, 3], num_classes=num_classes, include_top=include_top)
169. def resnet50(num_classes=1000, include_top=True):
170.     # https://download.pytorch.org/models/resnet50-19c8e357.pth
171.     return ResNet(Bottleneck, [3, 4, 6, 3], num_classes=num_classes, include_top=include_top)
174. def resnet101(num_classes=1000, include_top=True):
175.     # https://download.pytorch.org/models/resnet101-5d3b4d8f.pth
176.     return ResNet(Bottleneck, [3, 4, 23, 3], num_classes=num_classes, include_top=include_top)
179. def resnext50_32x4d(num_classes=1000, include_top=True):
180.     # https://download.pytorch.org/models/resnext50_32x4d-7cdf4587.pth
181.     groups = 32
182.     width_per_group = 4
183.     return ResNet(Bottleneck, [3, 4, 6, 3],
184.                   num_classes=num_classes,
185.                   include_top=include_top,
186.                   groups=groups,
187.                   width_per_group=width_per_group)
190. def resnext101_32x8d(num_classes=1000, include_top=True):
191.     # https://download.pytorch.org/models/resnext101_32x8d-8ba56ff5.pth
192.     groups = 32
193.     width_per_group = 8
194.     return ResNet(Bottleneck, [3, 4, 23, 3],
195.                   num_classes=num_classes,
196.                   include_top=include_top,
197.                   groups=groups,
198.                   width_per_group=width_per_group)

复制代码

四、model.py——定义ResNet34网络模子

batch_size = 16
epochs = 5

1. import os
2. import sys
3. import json
5. import torch
6. import torch.nn as nn
7. import torch.optim as optim
8. from torchvision import transforms, datasets
9. from tqdm import tqdm
10. from model import resnet50
13. def main():
14.     device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
15.     print("using {} device.".format(device))
17.     data_transform = {
18.         "train": transforms.Compose([transforms.RandomResizedCrop(224),
19.                                      transforms.RandomHorizontalFlip(),
20.                                      transforms.ToTensor(),
21.                                      transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])]),
22.         "val": transforms.Compose([transforms.Resize(256),
23.                                    transforms.CenterCrop(224),
24.                                    transforms.ToTensor(),
25.                                    transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])])}
27.     data_root = os.path.abspath(os.path.join(os.getcwd(), "../.."))  # get data root path
28.     image_path = os.path.join(data_root, "zjdata", "flower_data")  # flower data set path
29.     assert os.path.exists(image_path), "{} path does not exist.".format(image_path)
30.     train_dataset = datasets.ImageFolder(root=os.path.join(image_path, "train"),
31.                                          transform=data_transform["train"])
32.     train_num = len(train_dataset)
34.     # {'daisy':0, 'dandelion':1, 'roses':2, 'sunflower':3, 'tulips':4}
35.     flower_list = train_dataset.class_to_idx
36.     cla_dict = dict((val, key) for key, val in flower_list.items())
37.     # write dict into json file
38.     json_str = json.dumps(cla_dict, indent=4)
39.     with open('class_indices.json', 'w') as json_file:
40.         json_file.write(json_str)
42.     batch_size = 16
43.     nw = min([os.cpu_count(), batch_size if batch_size > 1 else 0, 8])  # number of workers
44.     print('Using {} dataloader workers every process'.format(nw))
46.     train_loader = torch.utils.data.DataLoader(train_dataset,
47.                                                batch_size=batch_size, shuffle=True,
48.                                                num_workers=0)
50.     validate_dataset = datasets.ImageFolder(root=os.path.join(image_path, "val"),
51.                                             transform=data_transform["val"])
52.     val_num = len(validate_dataset)
53.     validate_loader = torch.utils.data.DataLoader(validate_dataset,
54.                                                   batch_size=batch_size, shuffle=False,
55.                                                   num_workers=nw)
57.     print("using {} images for training, {} images for validation.".format(train_num,
58.                                                                            val_num))
59.    
60.     net = resnet50(num_classes=5, include_top=True)
61.     net.to(device)
63.     # define loss function
64.     loss_function = nn.CrossEntropyLoss()
66.     # construct an optimizer
67.     params = [p for p in net.parameters() if p.requires_grad]
68.     optimizer = optim.Adam(params, lr=0.1)
70.     epochs = 5
71.     best_acc = 0.0
72.     save_path = './resNet50.pth'
73.     train_steps = len(train_loader)
74.     for epoch in range(epochs):
75.         # train
76.         net.train()
77.         running_loss = 0.0
78.         train_bar = tqdm(train_loader, file=sys.stdout)
79.         for step, data in enumerate(train_bar):
80.             images, labels = data
81.             optimizer.zero_grad()
82.             logits = net(images.to(device))
83.             loss = loss_function(logits, labels.to(device))
84.             loss.backward()
85.             optimizer.step()
87.             # print statistics
88.             running_loss += loss.item()
90.             train_bar.desc = "train epoch[{}/{}] loss:{:.3f}".format(epoch + 1,
91.                                                                      epochs,
92.                                                                      loss)
94.         # validate
95.         net.eval()
96.         acc = 0.0  # accumulate accurate number / epoch
97.         with torch.no_grad():
98.             val_bar = tqdm(validate_loader, file=sys.stdout)
99.             for val_data in val_bar:
100.                 val_images, val_labels = val_data
101.                 outputs = net(val_images.to(device))
102.                 # loss = loss_function(outputs, test_labels)
103.                 predict_y = torch.max(outputs, dim=1)[1]
104.                 acc += torch.eq(predict_y, val_labels.to(device)).sum().item()
106.                 val_bar.desc = "valid epoch[{}/{}]".format(epoch + 1,
107.                                                            epochs)
109.         val_accurate = acc / val_num
110.         print('[epoch %d] train_loss: %.3f  val_accuracy: %.3f' %
111.               (epoch + 1, running_loss / train_steps, val_accurate))
113.         if val_accurate > best_acc:
114.             best_acc = val_accurate
115.             torch.save(net.state_dict(), save_path)
117.     print('Finished Training')
120. if __name__ == '__main__':
121.     main()

复制代码

训练中截图

五、predict.py——使用训练好的网络参数后，用自己找的图像举行分类测试

1. import os
2. import json
4. import torch
5. from PIL import Image
6. from torchvision import transforms
7. import matplotlib.pyplot as plt
9. from model import resnet34
12. def main():
13.     device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
15.     data_transform = transforms.Compose(
16.         [transforms.Resize(256),
17.          transforms.CenterCrop(224),
18.          transforms.ToTensor(),
19.          transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])])
21.     # load image
22.     img_path = "./1.jpg"
23.     assert os.path.exists(img_path), "file: '{}' dose not exist.".format(img_path)
24.     img = Image.open(img_path)
25.     plt.imshow(img)
26.     # [N, C, H, W]
27.     img = data_transform(img)
28.     # expand batch dimension
29.     img = torch.unsqueeze(img, dim=0)
31.     # read class_indict
32.     json_path = './class_indices.json'
33.     assert os.path.exists(json_path), "file: '{}' dose not exist.".format(json_path)
35.     with open(json_path, "r") as f:
36.         class_indict = json.load(f)
38.     # create model
39.     model = resnet34(num_classes=5).to(device)
41.     # load model weights
42.     weights_path = "./resNet50.pth"
43.     assert os.path.exists(weights_path), "file: '{}' dose not exist.".format(weights_path)
44.     model.load_state_dict(torch.load(weights_path, map_location=device))
46.     # prediction
47.     model.eval()
48.     with torch.no_grad():
49.         # predict class
50.         output = torch.squeeze(model(img.to(device))).cpu()
51.         predict = torch.softmax(output, dim=0)
52.         predict_cla = torch.argmax(predict).numpy()
54.     print_res = "class: {}   prob: {:.3}".format(class_indict[str(predict_cla)],
55.                                                  predict[predict_cla].numpy())
56.     plt.title(print_res)
57.     for i in range(len(predict)):
58.         print("class: {:10}   prob: {:.3}".format(class_indict[str(i)],
59.                                                   predict[i].numpy()))
60.     plt.show()
63. if __name__ == '__main__':
64.     main()

复制代码

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。