devbox
Guff_9hys
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

基于轻量级神经网络GhostNet开发构建的200种鸟类细粒度识别分析系统_ghostnest 信号识别

作者：Guff_9hys | 2024-07-02 02:38:37

赞

踩

ghostnest 信号识别

最近项目需要用到轻量级的网络模型，后期考虑进一步的剪枝和量化达到加速推理的目的，正好有时间就想着基于实际的数据集来开发构建项目做测试，本文的核心目的就是选定轻量级神经网络模型GhostNet来开发构建细粒度鸟类识别系统，首先看下效果图：

简单看下数据集：

数据集随机划分相关的实现可以看我前文的介绍，这里直接给出核心代码实现：

  1. # 加载解析创建数据集
  2. if not os.path.exists("dataset.json"):
  3.     train_dataset = []
  4.     test_dataset = []
  5.     all_dataset = []
  6.     classes_list = os.listdir(datasetDir)
  7.     classes_list.sort()
  8.     print("classes_list: ", classes_list)
  9.     with open("weights/classes.txt","w") as f:
  10.         for one_label in classes_list:
  11.             f.write(one_label.strip()+"\n")
  12.     print("classes file write success!")
  13.     num_classes=len(classes_list)
  14.     for one_label in os.listdir(datasetDir):
  15.         oneDir = datasetDir + one_label + "/"
  16.         for one_pic in os.listdir(oneDir):
  17.             one_path = oneDir + one_pic
  18.             try:
  19.                 one_ind = classes_list.index(one_label)
  20.                 all_dataset.append([one_ind, one_path])
  21.             except:
  22.                 pass
  23.     train_ratio = 0.90
  24.     train_num = int(train_ratio * len(all_dataset))
  25.     all_inds = list(range(len(all_dataset)))
  26.     train_inds = random.sample(all_inds, train_num)
  27.     test_inds = [one for one in all_inds if one not in train_inds]
  28.     for one_ind in train_inds:
  29.         train_dataset.append(all_dataset[one_ind])
  30.     for one_ind in test_inds:
  31.         test_dataset.append(all_dataset[one_ind])
  32.     dataset = {}
  33.     dataset["train"] = train_dataset
  34.     dataset["test"] = test_dataset
  35.     with open("dataset.json", "w") as f:
  36.         f.write(json.dumps(dataset))
  37. else:
  38.     with open("dataset.json") as f:
  39.         dataset = json.load(f)
  40.     train_dataset = dataset["train"]
  41.     test_dataset = dataset["test"]
  42.     with open("weights/classes.txt","r") as f:
  43.         classes_list=[one.strip() for one in f.readlines() if one.strip()]
  44.     print("classes_list: ", classes_list)
  45.     num_classes = len(classes_list)
  46. print("train_dataset_size: ", len(train_dataset))
  47. print("test_dataset_size: ", len(test_dataset))

以下是一些常用的轻量级卷积神经网络模型：

  1. MobileNet：MobileNet是一种基于深度可分离卷积的轻量级模型，通过Depthwise Separable Convolution减少参数量和计算量，适用于移动设备上的图像分类和目标检测。

  2. ShuffleNet：ShuffleNet通过使用通道洗牌操作来减少参数量和计算量。它采用逐点卷积和组卷积，将通道分为组并进行特征图的混洗，以增加特征的多样性。

  3. EfficientNet：EfficientNet是一系列模型，通过使用复合缩放方法在深度、宽度和分辨率上进行均衡扩展。它在减少参数和计算量的同时，保持高准确性。

  4. MobileNetV3：MobileNetV3是MobileNet的改进版本，引入了候选网络和网络搜索方法，通过优化模型结构和激活函数，进一步提升了轻量级模型的性能。

  5. ProxylessNAS：ProxylessNAS是使用神经网络搜索算法来自动搜索轻量级模型结构的方法。它通过替代器生成网络中的每个操作，以有效地搜索高效的模型结构。

  6. SqueezeNet：SqueezeNet是一种极小化的卷积神经网络模型，使用Fire模块将降维卷积和扩展卷积组合在一起，以减少参数量和计算量。

这些轻量级模型在参数量和计算量上相对较少，适用于资源受限的设备或场景。然而，每个模型都有不同的性能和特点，根据应用需求和资源限制，选择合适的模型进行使用。同时，还可以根据具体任务的要求进行模型的调整和优化。

GhostNet是一种轻量级的卷积神经网络模型，旨在在计算资源有限的设备上实现高效的图像分类和目标检测。其主要原理是通过使用Ghost Module来减少参数量和计算量，并提高模型在资源受限条件下的性能。

Ghost Module是GhostNet的关键组成部分，其主要思想是通过将一个普通的卷积层分解为两个部分：主要卷积（或称为Ghost指示器）和辅助卷积。具体构建原理如下：

  1. 主要卷积（Ghost指示器）：该部分包含少量的输出通道数（称为精简通道），可以看作是对原始卷积的一种降维表示。它对输入进行低维特征提取，并通过学习有效的过滤器来减少参数量和计算量。

  2. 辅助卷积：该部分包含更多的输出通道数（称为扩展通道），用于捕捉更丰富的特征表达。这种设计有助于模型在较少的参数量下保持较高的表示能力，提高对复杂图像的判别能力。

GhostNet模型的优点如下：

  1. 轻量高效：GhostNet通过使用Ghost Module，减少了模型的参数量和计算量，使得它在计算资源受限的设备上运行速度更快，能够满足更多应用的需求。

  2. 参数效率：Ghost Module通过以较少的参数产生较多的特征图，提高了参数的利用效率。这使得模型更具可扩展性，并能够更好地适应低功耗的设备和移动端应用需求。

  3. 准确性保持：尽管GhostNet是为了追求高效而设计的，但经过实证研究表明，在一些图像分类和目标检测任务中，它的准确性能够与一些常用的大型模型相媲美，或接近。

GhostNet模型的缺点如下：

  1. 空间复杂性：尽管GhostNet在参数和计算量上显著减少，但由于采用了辅助卷积来提取更丰富的特征，其空间复杂性相对较高。这可能使得在计算资源极度有限的设备上推理速度较慢。

  2. 特定任务的局限性：GhostNet主要用于图像分类和目标检测任务。对于其他类型的任务，如语义分割或实例分割等，GhostNet可能需要额外的定制和改进来适应任务的需求。

总之，GhostNet作为一种轻量级的模型设计，通过Ghost Module降低了模型的参数量和计算量，提高了在计算资源有限的设备上的性能。尽管存在一些局限性，但它在保持一定准确性的同时，能够在资源受限情况下提供高效的图像分类和目标检测能力。

在以往的项目中使用Mobilenet模型居多，较少使用GhostNet，所以这里以实地项目开发的方式也是想进一步熟悉GhostNet模型，这里模型搭建实现代码如下所示：

  1. # encoding:utf-8
  2. from __future__ import division
  3.  
  4.  
  5. """
  6. __Author__:沂水寒城
  7. 功能：  GhostNet
  8. """
  9.  
  10.  
  11. import torch
  12. import torch.nn as nn
  13. import math
  14. import numpy as np
  15. from torch.hub import load_state_dict_from_url
  16. from utils.utils import load_weights_from_state_dict
  17.  
  18.  
  19.  
  20. def _make_divisible(v, divisor, min_value=None):
  21.     """
  22.     参考
  23.     https://github.com/tensorflow/models/blob/master/research/slim/nets/mobilenet/mobilenet.py
  24.     """
  25.     if min_value is None:
  26.         min_value = divisor
  27.     new_v = max(min_value, int(v + divisor / 2) // divisor * divisor)
  28.     if new_v < 0.9 * v:
  29.         new_v += divisor
  30.     return new_v
  31.  
  32.  
  33. class SELayer(nn.Module):
  34.     """
  35.     SE Layer
  36.     """
  37.     def __init__(self, channel, reduction=4):
  38.         super(SELayer, self).__init__()
  39.         self.avg_pool = nn.AdaptiveAvgPool2d(1)
  40.         self.fc = nn.Sequential(
  41.             nn.Linear(channel, channel // reduction),
  42.             nn.ReLU(inplace=True),
  43.             nn.Linear(channel // reduction, channel),
  44.         )
  45.  
  46.     def forward(self, x):
  47.         b, c, _, _ = x.size()
  48.         y = self.avg_pool(x).view(b, c)
  49.         y = self.fc(y).view(b, c, 1, 1)
  50.         y = torch.clamp(y, 0, 1)
  51.         return x * y
  52.  
  53.  
  54. def depthwise_conv(inp, oup, kernel_size=3, stride=1, relu=False):
  55.     """
  56.     DW
  57.     """
  58.     return nn.Sequential(
  59.         nn.Conv2d(
  60.             inp, oup, kernel_size, stride, kernel_size // 2, groups=inp, bias=False
  61.         ),
  62.         nn.BatchNorm2d(oup),
  63.         nn.ReLU(inplace=True) if relu else nn.Sequential(),
  64.     )
  65.  
  66.  
  67. class GhostModule(nn.Module):
  68.     """
  69.     Ghost
  70.     """
  71.     def __init__(
  72.         self, inp, oup, kernel_size=1, ratio=2, dw_size=3, stride=1, relu=True
  73.     ):
  74.         super(GhostModule, self).__init__()
  75.         self.oup = oup
  76.         init_channels = math.ceil(oup / ratio)
  77.         new_channels = init_channels * (ratio - 1)
  78.  
  79.         self.primary_conv = nn.Sequential(
  80.             nn.Conv2d(
  81.                 inp, init_channels, kernel_size, stride, kernel_size // 2, bias=False
  82.             ),
  83.             nn.BatchNorm2d(init_channels),
  84.             nn.ReLU(inplace=True) if relu else nn.Sequential(),
  85.         )
  86.  
  87.         self.cheap_operation = nn.Sequential(
  88.             nn.Conv2d(
  89.                 init_channels,
  90.                 new_channels,
  91.                 dw_size,
  92.                 1,
  93.                 dw_size // 2,
  94.                 groups=init_channels,
  95.                 bias=False,
  96.             ),
  97.             nn.BatchNorm2d(new_channels),
  98.             nn.ReLU(inplace=True) if relu else nn.Sequential(),
  99.         )
  100.  
  101.     def forward(self, x):
  102.         x1 = self.primary_conv(x)
  103.         x2 = self.cheap_operation(x1)
  104.         out = torch.cat([x1, x2], dim=1)
  105.         return out[:, : self.oup, :, :]
  106.  
  107.  
  108. class GhostBottleneck(nn.Module):
  109.     """
  110.     GhostBottleneck
  111.     """
  112.     def __init__(self, inp, hidden_dim, oup, kernel_size, stride, use_se):
  113.         super(GhostBottleneck, self).__init__()
  114.         assert stride in [1, 2]
  115.         self.conv = nn.Sequential(
  116.             GhostModule(inp, hidden_dim, kernel_size=1, relu=True),
  117.             depthwise_conv(hidden_dim, hidden_dim, kernel_size, stride, relu=False)
  118.             if stride == 2
  119.             else nn.Sequential(),
  120.             SELayer(hidden_dim) if use_se else nn.Sequential(),
  121.             GhostModule(hidden_dim, oup, kernel_size=1, relu=False),
  122.         )
  123.         if stride == 1 and inp == oup:
  124.             self.shortcut = nn.Sequential()
  125.         else:
  126.             self.shortcut = nn.Sequential(
  127.                 depthwise_conv(inp, inp, 3, stride, relu=True),
  128.                 nn.Conv2d(inp, oup, 1, 1, 0, bias=False),
  129.                 nn.BatchNorm2d(oup),
  130.             )
  131.  
  132.     def forward(self, x):
  133.         return self.conv(x) + self.shortcut(x)
  134.  
  135.  
  136. class GhostNet(nn.Module):
  137.     """
  138.     GhostNet
  139.     """
  140.     def __init__(self, cfgs, num_classes=1000, width_mult=1.0):
  141.         super(GhostNet, self).__init__()
  142.         self.cfgs = cfgs
  143.         output_channel = _make_divisible(16 * width_mult, 4)
  144.         layers = [
  145.             nn.Sequential(
  146.                 nn.Conv2d(3, output_channel, 3, 2, 1, bias=False),
  147.                 nn.BatchNorm2d(output_channel),
  148.                 nn.ReLU(inplace=True),
  149.             )
  150.         ]
  151.         input_channel = output_channel
  152.         block = GhostBottleneck
  153.         for k, exp_size, c, use_se, s in self.cfgs:
  154.             output_channel = _make_divisible(c * width_mult, 4)
  155.             hidden_channel = _make_divisible(exp_size * width_mult, 4)
  156.             layers.append(
  157.                 block(input_channel, hidden_channel, output_channel, k, s, use_se)
  158.             )
  159.             input_channel = output_channel
  160.         self.features = nn.Sequential(*layers)
  161.         output_channel = _make_divisible(exp_size * width_mult, 4)
  162.         self.squeeze = nn.Sequential(
  163.             nn.Conv2d(input_channel, output_channel, 1, 1, 0, bias=False),
  164.             nn.BatchNorm2d(output_channel),
  165.             nn.ReLU(inplace=True),
  166.             nn.AdaptiveAvgPool2d((1, 1)),
  167.         )
  168.         input_channel = output_channel
  169.         output_channel = 1280
  170.         self.classifier = nn.Sequential(
  171.             nn.Linear(input_channel, output_channel, bias=False),
  172.             nn.BatchNorm1d(output_channel),
  173.             nn.ReLU(inplace=True),
  174.             nn.Dropout(0.2),
  175.             nn.Linear(output_channel, num_classes),
  176.         )
  177.         self._initialize_weights()
  178.  
  179.     def forward(self, x, need_fea=False):
  180.         if need_fea:
  181.             features, features_fc = self.forward_features(x, need_fea)
  182.             x = self.classifier(features_fc)
  183.             return features, features_fc, x
  184.         else:
  185.             x = self.forward_features(x)
  186.             x = self.classifier(x)
  187.             return x
  188.  
  189.     def forward_features(self, x, need_fea=False):
  190.         if need_fea:
  191.             input_size = x.size(2)
  192.             scale = [4, 8, 16, 32]
  193.             features = [None, None, None, None]
  194.             for idx, layer in enumerate(self.features):
  195.                 x = layer(x)
  196.                 if input_size // x.size(2) in scale:
  197.                     features[scale.index(input_size // x.size(2))] = x
  198.             x = self.squeeze(x)
  199.             return features, x.view(x.size(0), -1)
  200.         else:
  201.             x = self.features(x)
  202.             x = self.squeeze(x)
  203.             return x.view(x.size(0), -1)
  204.  
  205.     def _initialize_weights(self):
  206.         for m in self.modules():
  207.             if isinstance(m, nn.Conv2d):
  208.                 nn.init.kaiming_normal_(m.weight, mode="fan_out", nonlinearity="relu")
  209.             elif isinstance(m, nn.BatchNorm2d):
  210.                 m.weight.data.fill_(1)
  211.                 m.bias.data.zero_()
  212.  
  213.     def cam_layer(self):
  214.         return self.features[-1]

可以直接去华为开源仓库里面或者是开源社区其他的项目里面选择自己喜欢的代码实现即可，不需要自己去重头实现，理解应用即可。这里就不再赘述了，很多项目整体已经是比较完善的了。

这里对模型预测结果也进行了簇群可视化，如下所示：

这里类别比较多，显得比较混乱一些。

在绘制混淆矩阵的时候我们发现，200个类别的混淆矩阵基本没法看，后面想到了一个折中的办法就是不要精确的混淆矩阵，粗糙的实现，我们实现了按指定数量分段绘制混淆矩阵，如下所示：

这里可以人为设定单段绘制的最大数量，比如我这里设定的就是50个，这种方法之所以说是粗糙是因为丢弃了部分数据，不然没有办法形成对角线矩阵，只是为了视觉效果采用的这种方法，其他场景不建议这样去做。

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/Guff_9hys/article/detail/778354
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号