RCNN学习笔记-MobileNet2-源码分析

已于 2023-02-12 13:23:47 修改
阅读量215 收藏 1
点赞数 2
分类专栏： 深度学习 文章标签： 学习 深度学习 人工智能
于 2022-12-07 16:11:33 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/guoguozgw/article/details/128220661
版权

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

网络中的亮点：

Ø Inverted Residuals（倒残差结构)
Ø Linear Bottlenecks
在这里插入图片描述
激活函数的不同，relu6.
在这里插入图片描述

Linear Bottlenecks

考虑一个由n层Li组成的深度神经网络，每层Li具有维数为hi×wi×di的激活张量。在本节中，我们将讨论这些激活张量的基本性质，我们将其视为具有di维的hi×wi“像素”的容器。非正式地，对于真实图像的输入集，我们说层激活集（对于任何层Li）形成了“感兴趣的部分”。长期以来，人们一直认为神经网络中感兴趣的部分可以嵌入在低维子空间中。换句话说，当我们观察深度卷积层的所有单个d通道像素时，这些值中编码的信息实际上位于某个流形中，而该流形又可嵌入低维子空间。
在这里插入图片描述
嵌入高维空间中的低维流形的ReLU变换示例。在这些示例中，使用随机矩阵T和ReLU，将这个矩阵嵌入到n维空间，然后使用T的逆矩阵将其投影回2D空间（还原回去）.在上面的例子中，n＝2，3导致信息丢失，其中流形的某些点彼此塌陷，而对于n＝15到30，变换是高度非凸的。
说明了ReLU激活函数对低维特征信息照成了大量损失。在倒残差结构中是两边细，中间粗的结构，所以两边都是低维的特征。所以使用线性激活函数

网络结构图

在这里插入图片描述
t指的是倍率，c指的是输出通道数，n指的是重复的次数，s指的是第一次的步距

网络结构块的组成部分

在这里插入图片描述
整体网络模型结构的输出：

MobileNetV2(
  (features): Sequential(
    (0): ConvBNReLU(
      (0): Conv2d(3, 32, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)
      (1): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (2): ReLU6(inplace=True)
    )
    (1): InvertedResidual(
      (conv): Sequential(
        (0): ConvBNReLU(
          (0): Conv2d(32, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=32, bias=False)
          (1): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
          (2): ReLU6(inplace=True)
        )
        (1): Conv2d(32, 16, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (2): BatchNorm2d(16, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      )
    )
    (2): InvertedResidual(
      (conv): Sequential(
        (0): ConvBNReLU(
          (0): Conv2d(16, 96, kernel_size=(1, 1), stride=(1, 1), bias=False)
          (1): BatchNorm2d(96, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
          (2): ReLU6(inplace=True)
        )
        (1): ConvBNReLU(
          (0): Conv2d(96, 96, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), groups=96, bias=False)
          (1): BatchNorm2d(96, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
          (2): ReLU6(inplace=True)
        )
        (2): Conv2d(96, 24, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (3): BatchNorm2d(24, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      )
    )
    (3): InvertedResidual(
      (conv): Sequential(
        (0): ConvBNReLU(
          (0): Conv2d(24, 144, kernel_size=(1, 1), stride=(1, 1), bias=False)
          (1): BatchNorm2d(144, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
          (2): ReLU6(inplace=True)
        )
        (1): ConvBNReLU(
          (0): Conv2d(144, 144, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=144, bias=False)
          (1): BatchNorm2d(144, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
          (2): ReLU6(inplace=True)
        )
        (2): Conv2d(144, 24, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (3): BatchNorm2d(24, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      )
    )
    (4): InvertedResidual(
      (conv): Sequential(
        (0): ConvBNReLU(
          (0): Conv2d(24, 144, kernel_size=(1, 1), stride=(1, 1), bias=False)
          (1): BatchNorm2d(144, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
          (2): ReLU6(inplace=True)
        )
        (1): ConvBNReLU(
          (0): Conv2d(144, 144, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), groups=144, bias=False)
          (1): BatchNorm2d(144, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
          (2): ReLU6(inplace=True)
        )
        (2): Conv2d(144, 32, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (3): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      )
    )
    (5): InvertedResidual(
      (conv): Sequential(
        (0): ConvBNReLU(
          (0): Conv2d(32, 192, kernel_size=(1, 1), stride=(1, 1), bias=False)
          (1): BatchNorm2d(192, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
          (2): ReLU6(inplace=True)
        )
        (1): ConvBNReLU(
          (0): Conv2d(192, 192, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=192, bias=False)
          (1): BatchNorm2d(192, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
          (2): ReLU6(inplace=True)
        )
        (2): Conv2d(192, 32, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (3): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      )
    )
    (6): InvertedResidual(
      (conv): Sequential(
        (0): ConvBNReLU(
          (0): Conv2d(32, 192, kernel_size=(1, 1), stride=(1, 1), bias=False)
          (1): BatchNorm2d(192, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
          (2): ReLU6(inplace=True)
        )
        (1): ConvBNReLU(
          (0): Conv2d(192, 192, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=192, bias=False)
          (1): BatchNorm2d(192, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
          (2): ReLU6(inplace=True)
        )
        (2): Conv2d(192, 32, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (3): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      )
    )
    (7): InvertedResidual(
      (conv): Sequential(
        (0): ConvBNReLU(
          (0): Conv2d(32, 192, kernel_size=(1, 1), stride=(1, 1), bias=False)
          (1): BatchNorm2d(192, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
          (2): ReLU6(inplace=True)
        )
        (1): ConvBNReLU(
          (0): Conv2d(192, 192, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), groups=192, bias=False)
          (1): BatchNorm2d(192, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
          (2): ReLU6(inplace=True)
        )
        (2): Conv2d(192, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (3): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      )
    )
    (8): InvertedResidual(
      (conv): Sequential(
        (0): ConvBNReLU(
          (0): Conv2d(64, 384, kernel_size=(1, 1), stride=(1, 1), bias=False)
          (1): BatchNorm2d(384, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
          (2): ReLU6(inplace=True)
        )
        (1): ConvBNReLU(
          (0): Conv2d(384, 384, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=384, bias=False)
          (1): BatchNorm2d(384, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
          (2): ReLU6(inplace=True)
        )
        (2): Conv2d(384, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (3): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      )
    )
    (9): InvertedResidual(
      (conv): Sequential(
        (0): ConvBNReLU(
          (0): Conv2d(64, 384, kernel_size=(1, 1), stride=(1, 1), bias=False)
          (1): BatchNorm2d(384, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
          (2): ReLU6(inplace=True)
        )
        (1): ConvBNReLU(
          (0): Conv2d(384, 384, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=384, bias=False)
          (1): BatchNorm2d(384, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
          (2): ReLU6(inplace=True)
        )
        (2): Conv2d(384, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (3): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      )
    )
    (10): InvertedResidual(
      (conv): Sequential(
        (0): ConvBNReLU(
          (0): Conv2d(64, 384, kernel_size=(1, 1), stride=(1, 1), bias=False)
          (1): BatchNorm2d(384, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
          (2): ReLU6(inplace=True)
        )
        (1): ConvBNReLU(
          (0): Conv2d(384, 384, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=384, bias=False)
          (1): BatchNorm2d(384, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
          (2): ReLU6(inplace=True)
        )
        (2): Conv2d(384, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (3): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      )
    )
    (11): InvertedResidual(
      (conv): Sequential(
        (0): ConvBNReLU(
          (0): Conv2d(64, 384, kernel_size=(1, 1), stride=(1, 1), bias=False)
          (1): BatchNorm2d(384, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
          (2): ReLU6(inplace=True)
        )
        (1): ConvBNReLU(
          (0): Conv2d(384, 384, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=384, bias=False)
          (1): BatchNorm2d(384, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
          (2): ReLU6(inplace=True)
        )
        (2): Conv2d(384, 96, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (3): BatchNorm2d(96, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      )
    )
    (12): InvertedResidual(
      (conv): Sequential(
        (0): ConvBNReLU(
          (0): Conv2d(96, 576, kernel_size=(1, 1), stride=(1, 1), bias=False)
          (1): BatchNorm2d(576, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
          (2): ReLU6(inplace=True)
        )
        (1): ConvBNReLU(
          (0): Conv2d(576, 576, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=576, bias=False)
          (1): BatchNorm2d(576, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
          (2): ReLU6(inplace=True)
        )
        (2): Conv2d(576, 96, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (3): BatchNorm2d(96, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      )
    )
    (13): InvertedResidual(
      (conv): Sequential(
        (0): ConvBNReLU(
          (0): Conv2d(96, 576, kernel_size=(1, 1), stride=(1, 1), bias=False)
          (1): BatchNorm2d(576, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
          (2): ReLU6(inplace=True)
        )
        (1): ConvBNReLU(
          (0): Conv2d(576, 576, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=576, bias=False)
          (1): BatchNorm2d(576, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
          (2): ReLU6(inplace=True)
        )
        (2): Conv2d(576, 96, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (3): BatchNorm2d(96, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      )
    )
    (14): InvertedResidual(
      (conv): Sequential(
        (0): ConvBNReLU(
          (0): Conv2d(96, 576, kernel_size=(1, 1), stride=(1, 1), bias=False)
          (1): BatchNorm2d(576, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
          (2): ReLU6(inplace=True)
        )
        (1): ConvBNReLU(
          (0): Conv2d(576, 576, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), groups=576, bias=False)
          (1): BatchNorm2d(576, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
          (2): ReLU6(inplace=True)
        )
        (2): Conv2d(576, 160, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (3): BatchNorm2d(160, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      )
    )
    (15): InvertedResidual(
      (conv): Sequential(
        (0): ConvBNReLU(
          (0): Conv2d(160, 960, kernel_size=(1, 1), stride=(1, 1), bias=False)
          (1): BatchNorm2d(960, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
          (2): ReLU6(inplace=True)
        )
        (1): ConvBNReLU(
          (0): Conv2d(960, 960, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=960, bias=False)
          (1): BatchNorm2d(960, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
          (2): ReLU6(inplace=True)
        )
        (2): Conv2d(960, 160, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (3): BatchNorm2d(160, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      )
    )
    (16): InvertedResidual(
      (conv): Sequential(
        (0): ConvBNReLU(
          (0): Conv2d(160, 960, kernel_size=(1, 1), stride=(1, 1), bias=False)
          (1): BatchNorm2d(960, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
          (2): ReLU6(inplace=True)
        )
        (1): ConvBNReLU(
          (0): Conv2d(960, 960, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=960, bias=False)
          (1): BatchNorm2d(960, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
          (2): ReLU6(inplace=True)
        )
        (2): Conv2d(960, 160, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (3): BatchNorm2d(160, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      )
    )
    (17): InvertedResidual(
      (conv): Sequential(
        (0): ConvBNReLU(
          (0): Conv2d(160, 960, kernel_size=(1, 1), stride=(1, 1), bias=False)
          (1): BatchNorm2d(960, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
          (2): ReLU6(inplace=True)
        )
        (1): ConvBNReLU(
          (0): Conv2d(960, 960, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=960, bias=False)
          (1): BatchNorm2d(960, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
          (2): ReLU6(inplace=True)
        )
        (2): Conv2d(960, 320, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (3): BatchNorm2d(320, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      )
    )
    (18): ConvBNReLU(
      (0): Conv2d(320, 1280, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (1): BatchNorm2d(1280, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (2): ReLU6(inplace=True)
    )
  )
  (avgpool): AdaptiveAvgPool2d(output_size=(1, 1))
  (classifier): Sequential(
    (0): Dropout(p=0.2, inplace=False)
    (1): Linear(in_features=1280, out_features=1000, bias=True)
  )
)

代码部分

import torch
import torch.nn as nn
from torchvision.models import mobilenet
#jiushi ji就是将input_channel*alpha之后将其调整为8的倍数。可能是为了硬件的配合。
def _make_divisible(ch, divisor=8, min_ch=None):
    if min_ch is None:
        min_ch = divisor
    # 调整到距离与他最近的8的倍数。
    new_ch = max(min_ch,int(ch+divisor/2) // divisor*divisor)
    if new_ch < 0.9*ch:
        new_ch += divisor
    return new_ch
#基础操作
class ConvBNReLU(nn.Sequential):
    def __init__(self, in_channel, out_channel, kernel_size=3, stride=1, groups=1):
        padding = (kernel_size - 1) // 2#这个是根据kerne——size来设定的
        super(ConvBNReLU, self).__init__(
            #当groups=1的时候，就是普通的卷积。当使用bn的时候，bais并没有用处。dw卷积也是使用那个conv2d来设置的
            nn.Conv2d(in_channel, out_channel, kernel_size, stride, padding, groups=groups, bias=False),
            nn.BatchNorm2d(out_channel),
            nn.ReLU6(inplace=True)
        )

#倒残差结构bottleneck，两头细，中间粗的结构。和resnet中的残差结构是类似的。只不过resnet中的结构是两头粗，中间细。
class InvertedResidual(nn.Module):
    #expand_ratio就是k的值了。
    #DW卷积的输入和输出是相同的
    def __init__(self, in_channel, out_channel, stride, expand_ratio):
        super(InvertedResidual, self).__init__()
        #输入通道数 和 扩展因子 进行相乘
        hidden_channel = in_channel * expand_ratio
        self.use_shortcut = stride == 1 and in_channel == out_channel

        layers = []
        #当t等于1的时候，就没有对通道数进行扩充，所以就不需要这个1*1的卷积。
        #当t（扩展因子）不等于1的时候，需要这个1*1的卷积来对通道数进行扩充。
        if expand_ratio != 1:
            # 1x1 pointwise conv
            layers.append(ConvBNReLU(in_channel, hidden_channel, kernel_size=1))
        #extend和append是相同的，但是这个extend可以进行批量插入。
        layers.extend([
            # 3x3 depthwise conv
            ConvBNReLU(hidden_channel, hidden_channel, stride=stride, groups=hidden_channel),
            # 1x1 pointwise conv(linear)
            nn.Conv2d(hidden_channel, out_channel, kernel_size=1, bias=False),
            nn.BatchNorm2d(out_channel),
        ])

        self.conv = nn.Sequential(*layers)

    def forward(self,x):
        if self.use_shortcut:
            return x+self.conv(x)
        else:
            return self.conv(x)

from torchvision.models import mobilenet_v2


class MobileNetV2(nn.Module):
    def __init__(self, num_classes=1000, alpha=1.0, round_nearest=8):
        super(MobileNetV2, self).__init__()
        block = InvertedResidual#就只有一个倒残差结构块。就是bottleneck结构了。
        #_make_divisible是为了将通道数调节为8（round_nearest）的整数倍
        input_channel = _make_divisible(32 * alpha, round_nearest)
        last_channel = _make_divisible(1280 * alpha, round_nearest)

        inverted_residual_setting = [
            # t, c, n, s
            [1, 16, 1, 1],#这里指的是第一个bottleneck结构。
            [6, 24, 2, 2],
            [6, 32, 3, 2],
            [6, 64, 4, 2],
            [6, 96, 3, 1],
            [6, 160, 3, 2],
            [6, 320, 1, 1],
        ]

        features = []
        # conv1 layer
        features.append(ConvBNReLU(3, input_channel, stride=2))#指定的是第一个普通的卷积块。
        # building inverted residual residual blockes
        for t, c, n, s in inverted_residual_setting:#开始遍历循环倒残差结构，两边细，中间粗的结构。
            output_channel = _make_divisible(c * alpha, round_nearest)
            for i in range(n):#chongfu重复的次数
                stride = s if i == 0 else 1#当i=0的时候，代表的是第一层，所以需要使用stride==s，否则就是1。
                #block代表的是倒残差结构
                features.append(block(input_channel, output_channel, stride, expand_ratio=t))
                input_channel = output_channel
        # building last several layers
        #特征处理层就已经处理完了。剩下的就是avgpool，conv2d层了/
        features.append(ConvBNReLU(input_channel, last_channel, 1))#conv2d

        # combine feature layers
        self.features = nn.Sequential(*features)

        # building classifier
        self.avgpool = nn.AdaptiveAvgPool2d((1, 1))
        self.classifier = nn.Sequential(
            nn.Dropout(0.2),
            nn.Linear(last_channel, num_classes)
        )

        # weight initialization 初始化权重
        for m in self.modules():
            if isinstance(m, nn.Conv2d):
                nn.init.kaiming_normal_(m.weight, mode='fan_out')
                if m.bias is not None:
                    nn.init.zeros_(m.bias)
            elif isinstance(m, nn.BatchNorm2d):
                nn.init.ones_(m.weight)
                nn.init.zeros_(m.bias)
            elif isinstance(m, nn.Linear):
                nn.init.normal_(m.weight, 0, 0.01)
                nn.init.zeros_(m.bias)

    def forward(self, x):
        x = self.features(x)
        x = self.avgpool(x)
        x = torch.flatten(x, 1)
        #因为接下来就是一个全连接层，和图片中的conv2d-1*1是等同的效果
        x = self.classifier(x)
        return x

if __name__ == '__main__':
    print(MobileNetV2())
要努力啊啊啊
关注
  • 2
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JSP学习笔记-2.pdf
11-28
JSP学习笔记-2.pdf
57.Faster RCNN学习笔记 - 很美味的小猪猪 - CSDN博客1
08-03
《Faster RCNN学习笔记——目标检测的关键技术》 Faster RCNN，全称为Fast Region-based Convolutional Neural Network，是目标检测领域的一种经典方法，它显著提升了目标检测的效率和准确性。本篇笔记将围绕Faster...
MobileNets V2神经网络简介与代码实战
修行之路
05-23 926
MobileNets V2神经网络简介与代码实战
深度学习网络模型 MobileNet系列MobileNet V1、MobileNet V2、MobileNet V3网络详解以及pytorch代码复现
guoqingru0311的博客
11-01 1万+
深度学习网络模型 MobileNet系列MobileNet V1、MobileNet V2、MobileNet V3网络详解以及pytorch代码复现 1、DW卷积与普通卷积计算量对比 DW与PW计算量 普通卷积计算量 计算量对比 2、MobileNet V1 MobileNet V1网络结构 MobileNet V1网络结构代码 3、MobileNet V2 倒残差结构模块 倒残差模块代码 MobileNet V2详细网络结构 MobileNet V2网络结构代码 4、MobileNet V3
MobileNet_v2代码
qq_46026509的博客
05-23 333
t:扩展因子c:输出特征矩阵的深度channeln:bottleneck的重复次数s:步距(针对第一层,其他为1)
轻量化网络：MobileNet-V2
热门推荐
人工智能技术学习与分享
01-23 14万+
创新点 正文 MobileNet-V2网络结构 MobileNetV2: 《Inverted Residuals and Linear Bottlenecks: Mobile Networks for Classification, Detection and Segmentation》 于2018年1月公开在arXiv(美[ˈɑ:rkaɪv]) ：https://arxi...
MobileNetV1详细原理（含torch源码）
Code_and516的博客
04-17 2200
MobilenetV1（含torch源码）—— cifar10
MobileNetV3详细原理（含torch源码）
Code_and516的博客
04-19 3523
MobilneNetV3详细原理（含torch源码）—— cifar10
autokeras学习笔记-安装篇
最新发布
06-07
autokeras学习笔记-安装篇
统计学习方法笔记-基于Python算法实现源码.zip
06-01
统计学习方法笔记-基于Python算法实现。统计学习方法笔记-基于Python算法实现 所有代码均可直接运行。统计学习方法笔记-基于Python算法实现。统计学习方法笔记-基于Python算法实现 所有代码均可直接运行。统计学习...
android学习笔记-clip.pdf
11-15
android学习笔记-clip.pdf
mobilenetV2.py
12-07
mobilenetV2 网络结构，实测可用，可以详细读懂代码，欢迎下载
MobileNet：MobileNet的实施和研究论文
02-18
移动网 实现了一个版本的MobileNet，并将其转换为虚构的研究论文。 假设我们在2012年，就创建并实施了该项目。
mobilenetv2:MobileNetV2的TensorFlow2实现
04-20
具有完整源代码的TensorFlow2版本的MobileNetv2 具有完整源代码的TensorFlow2版本的MobileNetv2。 使用Kaggle dogs-vs-cats数据集从头开始训练MobileNetv2模型。 当前状态 在ZCU102上测试 使用的工具：带有额外补丁的TensorFlow2.3和Vitis AI 1.3.2 数据集： 网络：MobileNetv2 介绍 我们将执行以下步骤： 下载并准备Kaggle dogs-vs-cats数据集。 将图像转换为TFRecords。 使用TensorFlow的内置Keras版本对自定义CNN进行培训和评估。 使用作为Vitis AI的一部分提供的Xilinx:registered:量化器对浮点模型进行量化。 使用dogs-vs-cats测试数据集评估量化模型。 编译量化模型以在目标板上执行。 使用提供的Python脚本在目标板上
mobilenetv2深度解析
朗云星空
08-31 5671
今天下午仔细review了mobilenetv2的论文，有了新的感觉，在这里留个记录，也跟大家分享一下。论文原文《MobileNetV2: Inverted Residuals and Linear Bottlenecks》 论文里面提出了下面几个结构，深度卷积就不说了，正常卷积可以分解为depthwise和pointwise两个卷积，减小运算量和参数数量。如下面，a是正常的卷积形式，b是深度卷...
mobilenet V1&V2讲解以及torch代码
沐雨金鳞
12-16 1638
详细理解见：MobileNet，从V1到V3，讲的非常通俗易懂，大赞。本文也是摘录自上述文章，做了少许改动，代码是自己写的。 Mobilenet V1 一句话精髓：MobileNetV1就是把VGG中的标准卷积层换成深度可分离卷积！！！ 深度可分离卷积就是将普通卷积拆分成为一个深度卷积和一个逐点卷积。 我们在进行普通卷积的时候，为了获取有效信息，一般在卷积缩小特征图大小的同时，会增加特征图...
SSD-MobileNetv2之获取featureMapShapes
Jason的博客
10-30 337
相关参考： Tensorflow检测API中的SSD锚定 https://github.com/tensorflow/models 安装Tensorflow Object Detection API后在models/research/object_detection下新建getFeatureMapShapes.py import tensorflow as tf from object_detection.anchor_generators.multiple_grid_anchor_generator i
深度学习（七十）darknet 实现编写mobilenet源码
hjimce的专栏
07-27 1万+
)parse.c文件中函数string_to_layer_type，添加网络层类型解析： if (strcmp(type, "[depthwise_convolutional]") == 0) return DEPTHWISE_CONVOLUTIONAL; (2)darknet.h文件中枚举类型LAYER_TYPE，添加网络层枚举类型： DEPTHWISE_CONVOLUTIONAL； (3)parse.c文件中函数parse_network_cfg添加网络层解析后进行构建： LAYER_T
MobileNet_v2论文详读
h__ang的博客
03-08 3275
原文地址：MobileNetV2 一. 前沿 论文介绍了一种新的轻量级网络——MobileNetV2，与其他的轻量级网络相比，它在多个任务上都达到了最先进的水平。我们介绍了一种将轻量级网络应用在目标检测中的模型SSDLite，另外我们展示了如何通过DeepLabv3的一种简化形式——Mobile DeepLabv3来构建移动语义分割模型。 MobileNetV2是基于倒置的残差结构，普通的残差结...
faster-rcnn 和 mask-rcnn
09-03
- *1* *2* *3* [神经网络学习笔记7——目标检测，语义分割和实例分割中的RCNN、Fast RCNN、Faster RCNN、FCN和Mask RCNN](https://blog.csdn.net/qq_45848817/article/details/127965649)[target="_blank" data-...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值