第四周深度学习总结

最新推荐文章于 2024-05-14 10:05:12 发布

YYH-

最新推荐文章于 2024-05-14 10:05:12 发布

阅读量669

点赞数 1

文章标签：深度学习人工智能神经网络

本文链接：https://blog.csdn.net/weixin_72552113/article/details/126135552

版权

MobileNet

传统卷积神经网络，内存需求大、运算量大，导致无法在移动设备以及嵌入式设备上运。MobileNet网络是由google团队在2017年提出的，专注于移动端或者嵌入式设备中的轻量级CNN网络。相比传统卷积神经网络，在准确率小幅降低的前提下大大减少模型参数与运算量。

MobileNet V1

网络中的亮点：

Depthwise Convolution（大大减少运算量和参数数量）
增加超参数α、β

传统卷积：

卷积核channel = 输入特征矩阵channel
输出特征矩阵channel = 卷积核个数

DW（Depthwise Conv）卷积：

卷积核channel=1
输入特征矩阵channel=卷积核个数=输出特征矩阵channel

PW（Pointwise Conv）卷积：

卷积核大小为1×1

参数对比：

MobileNet V2

MobileNet V2网络是由google团队在2018年提出的，相比MobileNet V1网络，准确率更高，模型更小。

网络中的亮点：

Inverted Residuals（倒残差结构）
Linear Bottlenecks

倒残差结构（Inverted Residuals block）使用ReLu6激活函数

$y=ReLU6(x)=min(max(x,0),6)$

Linear Bottlenecks:

ReLU激活函数对低纬特征信息造成大量损失，所以最后使用线性激活函数。

MobileNet V3

网络中的亮点：

更新block（bneck）
使用NAS（Neural Architecture Search）搜索参数
重新设计耗时层结构

更新block：

重新设计耗时层结构：

重新设计激活函数：

SENeT

为了从特征通道之间的关系去提升网络的性能，Momenta 的高级研发工程师胡杰，提出了Squeeze-and-Excitation Networks （简称SENet），显式地建模特征通道之间的相互依赖关系。另外，该网络并不引入一个新的空间维度来进行特征通道间的融合，而是采用了一种全新的“特征重标定”策略。具体来说，就是通过学习的方式来自动获取到每个特征通道的重要程度，然后依照这个重要程度去提升有用的特征并抑制对当前任务用处不大的特征。

基本原理：

Squeeze 操作：顺着空间维度来进行特征压缩，将每个二维的特征通道变成一个实数，这个实数某种程度上具有全局的感受野，并且输出的维度和输入的特征通道数相匹配。它表征着在特征通道上响应的全局分布。
Excitation 操作：它是一个类似于循环神经网络中门的机制。通过参数来为每个特征通道生成权重，其中参数被学习用来显式地建模特征通道间的相关性。
Reweight 操作：将Excitation的输出的权重看做是进过特征选择后的每个特征通道的重要性，然后通过乘法逐通道加权到先前的特征上，完成在通道维度上的对原始特征的重标定。

下面是 BasicBlock 的代码：

class BasicBlock(nn.Module):
    def __init__(self, in_channels, out_channels, stride=1):
        super(BasicBlock, self).__init__()
        self.conv1 = nn.Conv2d(in_channels, out_channels, kernel_size=3, stride=stride, padding=1, bias=False)
        self.bn1 = nn.BatchNorm2d(out_channels)
        self.conv2 = nn.Conv2d(out_channels, out_channels, kernel_size=3, stride=1, padding=1, bias=False)
        self.bn2 = nn.BatchNorm2d(out_channels)

        # shortcut的输出维度和输出不一致时，用1*1的卷积来匹配维度
        self.shortcut = nn.Sequential()
        if stride != 1 or in_channels != out_channels:
            self.shortcut = nn.Sequential(
                nn.Conv2d(in_channels, out_channels, kernel_size=1, stride=stride, bias=False),
                nn.BatchNorm2d(out_channels))

        # 在 excitation 的两个全连接
        self.fc1 = nn.Conv2d(out_channels, out_channels//16, kernel_size=1) 
        self.fc2 = nn.Conv2d(out_channels//16, out_channels, kernel_size=1)

    #定义网络结构
    def forward(self, x):
        #feature map进行两次卷积得到压缩
        out = F.relu(self.bn1(self.conv1(x)))
        out = self.bn2(self.conv2(out))

        # Squeeze 操作：global average pooling
        w = F.avg_pool2d(out, out.size(2))
        
        # Excitation 操作： fc（压缩到16分之一）--Relu--fc（激到之前维度）--Sigmoid（保证输出为 0 至 1 之间）
        w = F.relu(self.fc1(w))
        w = F.sigmoid(self.fc2(w))

        # 重标定操作： 将卷积后的feature map与 w 相乘
        out = out * w 
        # 加上浅层特征图
        out += self.shortcut(x)
        #R elu激活
        out = F.relu(out)
        return out

SENet 网络：

#创建SENet网络
class SENet(nn.Module):
    def __init__(self):
        super(SENet, self).__init__()
        #最终分类的种类数
        self.num_classes = 10
        #输入深度为64
        self.in_channels = 64

        #先使用64*3*3的卷积核
        self.conv1 = nn.Conv2d(3, 64, kernel_size=3, stride=1, padding=1, bias=False)
        self.bn1 = nn.BatchNorm2d(64)
        #卷积层的设置，BasicBlock
        #2,2,2,2为每个卷积层需要的block块数
        self.layer1 = self._make_layer(BasicBlock,  64, 2, stride=1)
        self.layer2 = self._make_layer(BasicBlock, 128, 2, stride=2)
        self.layer3 = self._make_layer(BasicBlock, 256, 2, stride=2)
        self.layer4 = self._make_layer(BasicBlock, 512, 2, stride=2)
        #全连接
        self.linear = nn.Linear(512, self.num_classes)

    #实现每一层卷积
    #blocks为大layer中的残差块数
    #定义每一个layer有几个残差块，resnet18是2,2,2,2
    def _make_layer(self, block, out_channels, blocks, stride):
        strides = [stride] + [1]*(blocks-1)
        layers = []
        for stride in strides:
            layers.append(block(self.in_channels, out_channels, stride))
            self.in_channels = out_channels
        return nn.Sequential(*layers)

    #定义网络结构
    def forward(self, x):
        out = F.relu(self.bn1(self.conv1(x)))
        out = self.layer1(out)
        out = self.layer2(out)
        out = self.layer3(out)
        out = self.layer4(out)
        out = F.avg_pool2d(out, 4)
        out = out.view(out.size(0), -1)
        out = self.linear(out)
        return out

HybridSN

《HybridSN: Exploring 3-D–2-D CNN Feature Hierarchy for Hyperspectral Image Classification》这篇论文构建了一个混合网络解决高光谱图像分类问题，首先用 3D卷积，然后使用 2D卷积。

网络结构：

三维卷积部分：

conv1：（1, 30, 25, 25）， 8个 7x3x3 的卷积核 ==>（8, 24, 23, 23）
conv2：（8, 24, 23, 23）， 16个 5x3x3 的卷积核 ==>（16, 20, 21, 21）
conv3：（16, 20, 21, 21），32个 3x3x3 的卷积核 ==>（32, 18, 19, 19）

接下来要进行二维卷积，因此把前面的 32*18 reshape 一下，得到（576, 19, 19）

二维卷积：（576, 19, 19） 64个 3x3 的卷积核，得到（64, 17, 17）

接下来是一个 flatten 操作，变为 18496 维的向量，

接下来依次为256，128节点的全连接层，都使用比例为0.4的 Dropout，

最后输出为 16 个节点，是最终的分类类别数。

代码练习

网络部分补充：

class_num = 16

class HybridSN(nn.Module):
  def __init__(self):
    super(HybridSN, self).__init__()
    self.conv1 = nn.Sequential(
      nn.Conv3d( 1, 8, (7, 3, 3)),
      nn.BatchNorm3d(8)
    )
    self.conv2 = nn.Sequential(
      nn.Conv3d( 8, 16, (5, 3, 3)),
      nn.BatchNorm3d(16)
    )
    self.conv3 = nn.Sequential(
      nn.Conv3d( 16, 32, (3, 3, 3)),
      nn.BatchNorm3d(32)
    )
    self.conv4 = nn.Sequential(
      nn.Conv2d( 576, 64, 3),
      nn.BatchNorm2d(64)
    )
    self.fc1 = nn.Linear(18496,256)
    self.fc2 = nn.Linear(256,128)
    self.fc3 = nn.Linear(128,class_num)
    self.drop = nn.Dropout(p=0.4)

  def forward(self, x):
    out = F.relu(self.conv1(x))
    out = F.relu(self.conv2(out))
    out = F.relu(self.conv3(out))
    out = out.reshape(out.shape[0], -1, 19, 19)
    out = F.relu(self.conv4(out))
    out = out.reshape(out.shape[0],-1)
    out = F.relu(self.drop(self.fc1(out)))
    out = F.relu(self.drop(self.fc2(out)))
    out = self.fc3(out)

    return out

第一次测试结果：