• 基于ResNet框架的CNN

    数据准备

    DATA_URL = 'http://download.tensorflow.org/example_images/flower_photos.tgz'

    一、训练集和验证集的划分

    1. #spile_data.py
    2.  
    3. import os
    4. from shutil import copy
    5. import random
    6.  
    7.  
    8. def mkfile(file):
    9.     if not os.path.exists(file):
    10.         os.makedirs(file)
    11.  
    12.  
    13. file = 'flower_data/flower_photos'
    14. flower_class = [cla for cla in os.listdir(file) if ".txt" not in cla] #['daisy', 'dandelion', 'roses', 'sunflowers', 'tulips']
    15. mkfile('flower_data/train') #生成train文件夹
    16. for cla in flower_class:
    17.     mkfile('flower_data/train/'+cla) #在train文件夹下生成各个类别的文件夹
    18.  
    19. mkfile('flower_data/val')
    20. for cla in flower_class:
    21.     mkfile('flower_data/val/'+cla)
    22.  
    23. split_rate = 0.1
    24. for cla in flower_class:
    25.     cla_path = file + '/' + cla + '/'
    26.     images = os.listdir(cla_path)
    27.     num = len(images)
    28.     eval_index = random.sample(images, k=int(num*split_rate)) #在images中随机获取0.1的图片
    29.     for index, image in enumerate(images):
    30.         if image in eval_index:
    31.             image_path = cla_path + image
    32.             new_path = 'flower_data/val/' + cla
    33.             copy(image_path, new_path)
    34.         else:
    35.             image_path = cla_path + image
    36.             new_path = 'flower_data/train/' + cla
    37.             copy(image_path, new_path)
    38.         print("\r[{}] processing [{}/{}]".format(cla, index+1, num), end="")  # processing bar
    39.     print()
    40.  
    41. print("processing done!")

    二、ResNet网络

    1. import torch.nn as nn
    2. import math
    3. import torch.utils.model_zoo as model_zoo
    4. import mmd
    5. from attention import ChannelAttention
    6. from attention import SpatialAttention
    7. import torch
    8.  
    9.  
    10. __all__ = ['ResNet', 'resnet50']
    11.  
    12.  
    13. model_urls = {
    14.     'resnet50': 'https://download.pytorch.org/models/resnet50-19c8e357.pth',
    15. }
    16.  
    17. def conv3x3(in_planes, out_planes, stride=1,groups=1):
    18.     """3x3 convolution with padding"""
    19.     return nn.Conv2d(in_planes, out_planes, kernel_size=3, stride=stride,
    20.                      padding=1, bias=False)
    21.  
    22. def conv1x1(in_planes, out_planes, stride=1):
    23.     """1x1 convolution"""
    24.     return nn.Conv2d(in_planes, out_planes, kernel_size=1, stride=stride, bias=False)
    25.  
    26.  
    27. '''
    28. Resnet中BasicBlock结构,ResNet中使用的网络结构。分2步走：3x3; 3x3
    29. '''
    30. class BasicBlock(nn.Module):
    31.     expansion = 1  # 最后输出的通道数扩充的比例
    32.  
    33.     # BN层来加快网络模型的收敛速度/训练速度/解决梯度消失或者梯度爆炸的问题
    34.     # 对batch中所有的同一个channel的数据元素进行标准化处理。一个batch共享一套参数
    35.     # 即如果有C个通道，对N*H*W进行标准化处理，一共进行C次。
    36.  
    37.     def __init__(self, inplanes, planes, stride=1, downsample=None):
    38.         super(BasicBlock, self).__init__()
    39.         self.conv1 = conv3x3(inplanes, planes, stride)
    40.         self.bn1 = nn.BatchNorm2d(planes)
    41.         self.relu = nn.ReLU(inplace=True)
    42.         self.conv2 = conv3x3(planes, planes)
    43.         self.bn2 = nn.BatchNorm2d(planes)
    44.         self.downsample = downsample
    45.         self.stride = stride
    46.  
    47.     def forward(self, x):
    48.         residual = x
    49.  
    50.         out = self.conv1(x)
    51.         out = self.bn1(out)
    52.         out = self.relu(out)
    53.  
    54.         out = self.conv2(out)
    55.         out = self.bn2(out)
    56.  
    57.         # downsample是用一个1x1的卷积核处理，改变通道数，如果H/W尺度也不一样就设计stride
    58.         if self.downsample is not None:
    59.             residual = self.downsample(x)
    60.  
    61.         out += residual
    62.         out = self.relu(out)
    63.  
    64.         return out
    65.  
    66.  
    67. '''
    68. Resnet中Bottleneck结构,ResNet中使用的网络结构。目的是为了降低参数量，分三步走：
    69. 1数据降维(1x1)，2常规卷积核的卷积(3x3)，3数据升维(1x1)
    70. 结果图片长宽不变，通道数扩大4倍
    71. '''
    72. class Bottleneck(nn.Module):
    73.     expansion = 4  # 最后输出的通道数扩充的比例
    74.  
    75.     def __init__(self, inplanes, planes, stride=1, downsample=None, groups=1,
    76.                  base_width=64, norm_layer=None):
    77.         super(Bottleneck, self).__init__()
    78.         self.conv1 = nn.Conv2d(inplanes, planes, kernel_size=1, bias=False)
    79.         # BN层来加快网络模型的收敛速度/训练速度/解决梯度消失或者梯度爆炸的问题
    80.         # 对batch中所有的同一个channel的数据元素进行标准化处理。一个batch共享一套参数
    81.         # 即如果有C个通道，对N*H*W进行标准化处理，一共进行C次。
    82.         self.bn1 = nn.BatchNorm2d(planes)  # 卷积层后加BatchNorm2d，按照channel进行归一化
    83.         self.conv2 = nn.Conv2d(planes, planes, kernel_size=3, stride=stride,
    84.                                padding=1, bias=False)
    85.         self.bn2 = nn.BatchNorm2d(planes)
    86.         self.conv3 = nn.Conv2d(planes, planes * 4, kernel_size=1, bias=False)
    87.         self.bn3 = nn.BatchNorm2d(planes * 4)
    88.         self.relu = nn.ReLU(inplace=True)
    89.         self.downsample = downsample
    90.         self.dropout=nn.Dropout()
    91.         self.stride = stride
    92.  
    93.     def forward(self, x):
    94.         residual = x
    95.  
    96.         out = self.conv1(x)
    97.         out = self.bn1(out)
    98.         out = self.relu(out)
    99.  
    100.         out = self.conv2(out)
    101.         out = self.bn2(out)
    102.         out = self.relu(out)
    103.  
    104.         out = self.conv3(out)
    105.         out = self.bn3(out)
    106.  
    107.         # downsample是用一个1x1的卷积核处理，改变通道数，如果H/W尺度也不一样就设计stride
    108.         if self.downsample is not None:
    109.             residual = self.downsample(x)
    110.  
    111.         out += residual
    112.         out = self.relu(out)
    113.  
    114.         return out
    115.  
    116.  
    117. '''
    118. ResNet由以下组成：
    119. 1.conv1、norm1、relu（当指定了deep_stem，这三个将被stem代替）
    120. 2.maxpool
    121. 3.layer1~layer4（定义为ResLayer类，分别由多个BasicBlock或Bottleneck组成）
    122. '''
    123. class ResNet(nn.Module):
    124.     # 参数block指明残差块是两层或三层，参数layers指明每个卷积层需要的残差块数量，num_classes指明分类数，zero_init_residual是否初始化为0
    125.     def __init__(self, block, layers, num_classes=1000, zero_init_residual=False,
    126.                  groups=1, width_per_group=64, norm_layer=None):
    127.         super(ResNet, self).__init__()
    128.         if norm_layer is None:
    129.             norm_layer = nn.BatchNorm2d
    130.  
    131.         self.inplanes = 64
    132.         self.groups = groups
    133.         self.base_width = width_per_group
    134.         self.conv1 = nn.Conv2d(12, self.inplanes, kernel_size=7, stride=2, padding=3,
    135.                                bias=False)
    136.         self.bn1 = norm_layer(self.inplanes)
    137.         self.relu = nn.ReLU(inplace=True)
    138.  
    139.         # 网络的第一层加入注意力机制
    140.         # self.ca = ChannelAttention(self.inplanes)
    141.         # self.sa = SpatialAttention()
    142.  
    143.         self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)
    144.         self.layer1 = self._make_layer(block, 64, layers[0], norm_layer=norm_layer)
    145.         self.layer2 = self._make_layer(block, 128, layers[1], stride=2, norm_layer=norm_layer)
    146.         self.layer3 = self._make_layer(block, 256, layers[2], stride=2, norm_layer=norm_layer)
    147.         self.layer4 = self._make_layer(block, 512, layers[3], stride=2, norm_layer=norm_layer)
    148.  
    149.         # 网络的卷积层的最后一层加入注意力机制
    150.         # self.ca1 = ChannelAttention(self.inplanes)
    151.         # self.sa1 = SpatialAttention()
    152.  
    153.         self.avgpool = nn.AdaptiveAvgPool2d((1, 1))  # 自适应平均池化，指定输出(H，W)
    154.         self.fc = nn.Linear(512 * block.expansion, num_classes)
    155.  
    156.         for m in self.modules():
    157.             if isinstance(m, nn.Conv2d):
    158.                 nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu')
    159.             elif isinstance(m, (nn.BatchNorm2d, nn.GroupNorm)):
    160.                 nn.init.constant_(m.weight, 1)
    161.                 nn.init.constant_(m.bias, 0)
    162.  
    163.         if zero_init_residual:
    164.             for m in self.modules():
    165.                 if isinstance(m, Bottleneck):
    166.                     nn.init.constant_(m.bn3.weight, 0)
    167.                 elif isinstance(m, BasicBlock):
    168.                     nn.init.constant_(m.bn2.weight, 0)
    169.  
    170.     # 构造ResLayer类，layer1~layer4
    171.     # block：BasicBlock/Bottleneck; planes：块的输入通道数; blocks：块的数目
    172.     def _make_layer(self, block, planes, blocks, stride=1, norm_layer=None):
    173.         if norm_layer is None:
    174.             norm_layer = nn.BatchNorm2d
    175.         downsample = None  # downSample的作用于在残差连接时 将输入的图像的通道数变成和卷积操作的尺寸一致
    176.         if stride != 1 or self.inplanes != planes * block.expansion:
    177.             # 通道数恢复成一致/长宽恢复一致
    178.             downsample = nn.Sequential(
    179.                 conv1x1(self.inplanes, planes * block.expansion, stride),
    180.                 norm_layer(planes * block.expansion),
    181.             )
    182.  
    183.         layers = []
    184.         layers.append(block(self.inplanes, planes, stride, downsample, self.groups,
    185.                             self.base_width, norm_layer))
    186.         self.inplanes = planes * block.expansion
    187.         for _ in range(1, blocks):
    188.             layers.append(block(self.inplanes, planes, groups=self.groups,
    189.                                 base_width=self.base_width, norm_layer=norm_layer))
    190.  
    191.         return nn.Sequential(*layers)
    192.  
    193.     '''
    194.     卷积/池化后的tensor维度为(batchsize，channels，x，y)，其中x.size(0)指batchsize的值，
    195.     通过x.view(x.size(0), -1)将tensor的结构转换为了(batchsize, channels*x*y)
    196.     即将（channels，x，y）拉直，然后就可以和fc层连接
    197.     
    198.     因为最后avgpool(1,1)指定输出长*宽为1*1，通道为512*4，所以channels*x*y=2048
    199.     '''
    200.     def forward(self, x):
    201.         x = self.conv1(x)
    202.         x = self.bn1(x)
    203.         x = self.relu(x)
    204.  
    205.         # x = self.ca(x) * x
    206.         # x = self.sa(x) * x
    207.  
    208.         x = self.maxpool(x)
    209.  
    210.         x = self.layer1(x)
    211.         x = self.layer2(x)
    212.         x = self.layer3(x)
    213.         x = self.layer4(x)
    214.  
    215.         # x = self.ca1(x) * x
    216.         # x = self.sa1(x) * x
    217.  
    218.         x = self.avgpool(x)
    219.         x = x.view(x.size(0), -1)
    220.         #x=self.fc(x)
    221.  
    222.         return x
    223.  
    224. class DANNet(nn.Module):
    225.  
    226.     def __init__(self, num_classes=2):
    227.         super(DANNet, self).__init__()
    228.         self.sharedNet = resnet50(False)
    229.         self.cls_fc = nn.Linear(2048, num_classes)  # channels*x*y=2048*1*1，见上面的备注
    230.  
    231.     def forward(self, source, target):
    232.         loss = 0
    233.         source = self.sharedNet(source)
    234.         if self.training == True:
    235.             target = self.sharedNet(target)
    236.             # loss += mmd.mmd_rbf_accelerate(source, target)
    237.             loss += mmd.mmd_rbf_noaccelerate(source, target)
    238.  
    239.         source = self.cls_fc(source)
    240.         #target = self.cls_fc(target)
    241.  
    242.         return source, loss
    243.  
    244. def resnet50(pretrained=False, **kwargs):
    245.     """Constructs a ResNet-50 model.
    246.     Args:
    247.         pretrained (bool): If True, returns a model pre-trained on ImageNet
    248.     """
    249.     model = ResNet(Bottleneck, [3, 4, 6, 3], **kwargs)
    250.     if pretrained:
    251.         model.load_state_dict(model_zoo.load_url(model_urls['resnet50']))
    252.     return model

    三、训练模型

    1. #train.py
    2.  
    3. import torch
    4. import torch.nn as nn
    5. from torchvision import transforms, datasets
    6. import json
    7. import matplotlib.pyplot as plt
    8. import os
    9. import torch.optim as optim
    10. from model import resnet34, resnet101
    11. import torchvision.models.resnet
    12.  
    13.  
    14. device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
    15. print(device)
    16.  
    17. #数据增强操作，训练集：随机裁剪（RandomResizedCrop）、随机水平翻转（RandomHorizontalFlip）、转换为张量（ToTensor）以及归一化（Normalize）
    18. #验证集：大小调整（Resize）、中心裁剪（CenterCrop）、转换为张量（ToTensor）以及归一化（Normalize）
    19. data_transform = {
    20.     "train": transforms.Compose([transforms.RandomResizedCrop(224),
    21.                                  transforms.RandomHorizontalFlip(),
    22.                                  transforms.ToTensor(),
    23.                                  transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])]),#来自官网参数
    24.     "val": transforms.Compose([transforms.Resize(256),#将最小边长缩放到256
    25.                                transforms.CenterCrop(224),
    26.                                transforms.ToTensor(),
    27.                                transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])])}
    28.  
    29.  
    30. data_root = os.getcwd()
    31. image_path = data_root + "/flower_data/"  # flower data set path
    32.  
    33. train_dataset = datasets.ImageFolder(root=image_path + "train",
    34.                                      transform=data_transform["train"])
    35. train_num = len(train_dataset) #3306
    36.  
    37. flower_list = train_dataset.class_to_idx   #{'daisy': 0, 'dandelion': 1, 'roses': 2, 'sunflowers': 3, 'tulips': 4}
    38. cla_dict = dict((val, key) for key, val in flower_list.items())  #{0: 'daisy', 1: 'dandelion', 2: 'roses', 3: 'sunflowers', 4: 'tulips'}
    39. # write dict into json file
    40. json_str = json.dumps(cla_dict, indent=4)  #将cla_dict字典对象转换为JSON格式的字符串，并通过indent=4参数指定缩进为4个空格
    41. with open('class_indices.json', 'w') as json_file:
    42.     json_file.write(json_str)
    43.  
    44. batch_size = 16
    45. train_loader = torch.utils.data.DataLoader(train_dataset,
    46.                                            batch_size=batch_size, shuffle=True,
    47.                                            num_workers=0)
    48.  
    49. validate_dataset = datasets.ImageFolder(root=image_path + "/val",
    50.                                         transform=data_transform["val"])
    51. val_num = len(validate_dataset)  #364
    52. validate_loader = torch.utils.data.DataLoader(validate_dataset,
    53.                                               batch_size=batch_size, shuffle=False,
    54.                                               num_workers=0)
    55. #net = resnet34()
    56. net = resnet34(num_classes=5)
    57. # load pretrain weights
    58.  
    59. # model_weight_path = "./resnet34-pre.pth"
    60. # missing_keys, unexpected_keys = net.load_state_dict(torch.load(model_weight_path), strict=False)#载入模型参数
    61.  
    62. # for param in net.parameters():
    63. #     param.requires_grad = False
    64. # change fc layer structure
    65.  
    66. # inchannel = net.fc.in_features
    67. # net.fc = nn.Linear(inchannel, 5)
    68.  
    69.  
    70. net.to(device)  #将神经网络模型net移动到指定的设备上，这样模型就可以在GPU/CPU上计算
    71.  
    72. loss_function = nn.CrossEntropyLoss()  #损失函数
    73. optimizer = optim.Adam(net.parameters(), lr=0.0001)  #优化器
    74.  
    75. best_acc = 0.0
    76. save_path = './resNet34.pth'
    77. #一个epoch表示对整个训练数据集进行一次完整的迭代训练
    78. for epoch in range(3):
    79.     # train
    80.     net.train()
    81.     running_loss = 0.0
    82.     #step表示当前的步数（或者称为批次数），data则表示从train_loader中加载的数据对象
    83.     for step, data in enumerate(train_loader, start=0):
    84.         images, labels = data  #images:(16,3,224,224) labels:(16,)
    85.         optimizer.zero_grad()
    86.         logits = net(images.to(device)) #logits:(16,5)将输入的图像数据images传入神经网络net
    87.         loss = loss_function(logits, labels.to(device)) #1.6871 计算模型输出logits进行标准化（softmax）,再计算每个样本预测标签和真实标签的交叉熵，对于整个批次的样本，计算平均交叉熵损失
    88.         loss.backward()
    89.         optimizer.step()
    90.  
    91.         # print statistics
    92.         running_loss += loss.item()  #累加每个批次的损失值
    93.         # print train process
    94.         rate = (step+1)/len(train_loader)
    95.         a = "*" * int(rate * 50)
    96.         b = "." * int((1 - rate) * 50)
    97.         print("\rtrain loss: {:^3.0f}%[{}->{}]{:.4f}".format(int(rate*100), a, b, loss), end="")
    98.     print()
    99.  
    100.     # validate
    101.     net.eval()
    102.     acc = 0.0  # accumulate accurate number / epoch
    103.     with torch.no_grad():
    104.         for val_data in validate_loader:
    105.             val_images, val_labels = val_data
    106.             outputs = net(val_images.to(device))  # eval model only have last output layer
    107.             # loss = loss_function(outputs, test_labels)
    108.             predict_y = torch.max(outputs, dim=1)[1]  #torch.max包含两个维度信息，第一个维度是最大值，第二个维度是最大值对应的索引
    109.             acc += (predict_y == val_labels.to(device)).sum().item() #每一次的validate_loader中预测正确的个数，.item() 方法转换为标量
    110.         val_accurate = acc / val_num
    111.         if val_accurate > best_acc:
    112.             best_acc = val_accurate
    113.             torch.save(net.state_dict(), save_path)  #state_dict()方法返回模型的参数字典，save_path保存模型参数的文件路径
    114.         print('[epoch %d] train_loss: %.3f  test_accuracy: %.3f' %
    115.               (epoch + 1, running_loss / step, val_accurate))
    116.  
    117. print('Finished Training')

    四、预测

    1. #predict.py
    2.  
    3. import torch
    4. from model import resnet34
    5. from PIL import Image
    6. from torchvision import transforms
    7. import matplotlib.pyplot as plt
    8. import json
    9.  
    10. data_transform = transforms.Compose(
    11.     [transforms.Resize(256),
    12.      transforms.CenterCrop(224),
    13.      transforms.ToTensor(),
    14.      transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])])
    15.  
    16. # load image
    17. img = Image.open("./roses.jpg")
    18. plt.imshow(img)
    19. # [N, C, H, W]
    20. img = data_transform(img)
    21. # expand batch dimension
    22. img = torch.unsqueeze(img, dim=0)
    23.  
    24. # read class_indict
    25. try:
    26.     json_file = open('./class_indices.json', 'r')
    27.     class_indict = json.load(json_file)
    28. except Exception as e:
    29.     print(e)
    30.     exit(-1)
    31.  
    32. # create model
    33. model = resnet34(num_classes=5)
    34. # load model weights
    35. model_weight_path = "./resNet34.pth"
    36. model.load_state_dict(torch.load(model_weight_path))
    37. model.eval()
    38. with torch.no_grad():
    39.     # predict class
    40.     output = torch.squeeze(model(img))
    41.     predict = torch.softmax(output, dim=0)
    42.     predict_cla = torch.argmax(predict).numpy()
    43. print(class_indict[str(predict_cla)], predict[predict_cla].numpy())
    44. plt.show()

  • 相关阅读:
    Google Earth Engine ——影像无法正差加载可能是可视化参数设置得问题（visParams）
    无法启动此程序,因为计算机中丢失MSVCR71.dll的详细解决修复方法
    别人都在这个春暖花开的端午节吃粽子，而我在踏青学springboot数据持久化
    【数据结构】带头结点的单链表的头插法
    React之服务端渲染
    fpga内嵌逻辑分析仪使用方法
    [go学习笔记.第十章.面向对象编程] 8.面向对象的三大特性-封装
    CSS实现竖向步骤条
    网卡限速工具之WonderShaper
    docker一键安装debian/ubuntu桌面环境LXDE+VNC+Firefox
  • 原文地址：https://blog.csdn.net/qq_46458188/article/details/134517999