计算机视觉主干模型VGG16、MobileNetV2、ResNet50 pytorch版

已于 2022-08-29 15:40:57 修改
阅读量3.1k 收藏 19
点赞数 2
分类专栏： Pytorch 计算机视觉 文章标签： pytorch 计算机视觉 python
于 2022-08-27 19:08:58 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_35732321/article/details/126561343
版权

计算机视觉主干模型pytorch版

(1) VGG16 pytorch

  1. VGG16用3*3卷积提取特征，扩展通道数，通过最大池化缩小特征尺寸，经过5次后对数据平铺，最后经过两次全连接输出结果。

VGG16结构


'''
img[h,w,3] --> resize[224,224,3] -->
cnv1*2(k= 3,f = 64)[224,224,64] +   maxPool(s = 2)[112,112,64]-->
cnv2*2(k= 3,f = 128)[112,112,128] + maxPool(s = 2)[56,56,128]--->
cnv3*2(k= 3,f = 256)[56,56,256] +   maxPool(s = 2)[28,28,256]--->
cnv4*2(k= 3,f = 512)[28,28,512] +   maxPool(s = 2)[14,14,512]--->
cnv5*2(k= 3,f = 512)[14,14,512] +   maxPool(s = 2)[7,7,512]----->
flatten--> fc*2(4096) --> fc(1000) -->
out

'''

2 . VGG16代码

'''
VGG16 流程
cfgs['D'] (模型参数) -->
make_layers(cfgs['D']) (生成主干features)-->
VGG(make_layers(cfgs['D'])) （全连接 ）-->
pretrained (是否迁移学习) -->
num_classes != 1000 （重新定义分类层）
'''

import torch
import torchvision
import torch.nn as nn
from torch.autograd import Variable
from torchvision.models.utils import  load_state_dict_from_url

model_urls = {'vgg16': 'https://download.pytorch.org/models/vgg16-397923af.pth'}

class VGG(nn.Module):
    def __init__(self,features,num_classes=1000,init_weights=True):
        super(VGG, self).__init__()
        self.features = features
        self.avgpool = nn.AdaptiveAvgPool2d((7,7))  # output size of (7,7)
        self.clssifier = nn.Sequential(
            nn.Linear(512*7*7,4096),
            nn.ReLU(True),
            nn.Dropout(),
            nn.Linear(4096,4096),
            nn.ReLU(True),
            nn.Dropout(),
            nn.Linear(4096,num_classes))
        if init_weights:
            self._initialize_weights()

    def forward(self,x):
        x = self.features(x)   # [2, 512, 7, 7]
        x = self.avgpool(x)    # [2, 512, 7, 7]
        x = torch.flatten(x,1) # [2, 25088]  axis=1 从坐标轴起后面的数展平。
        x = self.clssifier(x)
        return x

    def _initialize_weights(self):
        for m in self.modules():
            if isinstance(m,nn.Conv2d):
                nn.init.normal_(m.weight)
                # nn.init.uniform(m.weight)
                #nn.init.kaiming_normal(m.weight,mode='fan_out',nonlinearity='relu')
                if m.bias is not None:
                    nn.init.constant_(m.bias,0)
            elif isinstance(m,nn.BatchNorm2d):
                nn.init.constant_(m.weight,1)
                nn.init.constant_(m.bias,0)
            elif isinstance(m,nn.Linear):
                nn.init.constant_(m.weight,0.01)
                nn.init.constant_(m.bias,0)

def make_layers(cfg,batch_norm=False):
    layers = []
    in_channels = 3
    for v in cfg:
        if v == 'M':
            layers += [nn.MaxPool2d(kernel_size = 2,stride=2)]
        else:
            conv2d = nn.Conv2d(in_channels,v,kernel_size=3,padding=1)
            if batch_norm:
                layers += [conv2d,nn.BatchNorm2d(v),nn.ReLU(inplace=True)]
            else:
                layers += [conv2d,nn.ReLU(inplace=True)]
            in_channels = v
    return nn.Sequential(*layers)

cfgs = {
    'D':[64,64,'M',128,128,'M',256,256,256,'M',512,512,512,'M',512,512,512,'M']}

def vgg16(pretrained=False,progress=True,num_classes=1000):
    model = VGG(make_layers(cfgs['D']))
    if pretrained:
        state_dict = load_state_dict_from_url(model_urls['vgg16'],
                                              model_dir = './model_data',
                                              progress=progress)
        model.load_state_dict(state_dict,strict=False)

    if num_classes != 1000:
        model.clssifier = nn.Sequential(
            nn.Linear(512*7*7,4096),
            nn.ReLU(True),
            nn.Dropout(),
            nn.Linear(4096,4096),
            nn.ReLU(True),
            nn.Dropout(),
            nn.Linear(4096,num_classes))
    return model


if __name__ == '__main__':
    x = torch.randn([2,3,224,224])
    model = vgg16(num_classes=2)
    y = model(x)
    print(y.shape)

'''
torch.Size([2, 2])

Process finished with exit code 0
'''

(2) MobileNetV1_pytorch

MobileNetV1用深度可分离卷积大大减少了参数的数量，先用3x3的卷积核依次和输入n 个特征卷积，得到n个输出特征，在用1x1卷积核进行普通的卷积得到输出特征。比如输入16个特征，需要输出32个特征，普通卷积的参数为16x3x3x32=4608个。用深度可分离卷积需要的参数量为16x3x3x1+16x1x1x32=656个。通过深度可分离卷积可以大大减少模型的参数。


'''
'''
import torch
import torch.nn as nn

def conv_bn(inp, oup, stride = 1):
    return nn.Sequential(
        nn.Conv2d(inp, oup, 3, stride, 1, bias=False),
        nn.BatchNorm2d(oup),
        nn.ReLU6(inplace=True)
    )

def conv_dw(inp, oup, stride = 1):
    return nn.Sequential(
        nn.Conv2d(inp, inp, 3, stride, 1, groups=inp, bias=False),
        nn.BatchNorm2d(inp),
        nn.ReLU6(inplace=True),

        nn.Conv2d(inp, oup, 1, 1, 0, bias=False),
        nn.BatchNorm2d(oup),
        nn.ReLU6(inplace=True),
    )

class MobileNetV1(nn.Module):
    def __init__(self):
        super(MobileNetV1, self).__init__()
        self.stage1 = nn.Sequential(
            # 640,640,3 -> 320,320,32
            conv_bn(3, 32, 2),
            # 320,320,32 -> 320,320,64
            conv_dw(32, 64, 1),

            # 320,320,64 -> 160,160,128
            conv_dw(64, 128, 2),
            conv_dw(128, 128, 1),

            # 160,160,128 -> 80,80,256
            conv_dw(128, 256, 2),
            conv_dw(256, 256, 1),
        )
        # 80,80,256 -> 40,40,512
        self.stage2 = nn.Sequential(
            conv_dw(256, 512, 2),
            conv_dw(512, 512, 1),
            conv_dw(512, 512, 1),
            conv_dw(512, 512, 1),
            conv_dw(512, 512, 1),
            conv_dw(512, 512, 1),
        )
        # 40,40,512 -> 20,20,1024
        self.stage3 = nn.Sequential(
            conv_dw(512, 1024, 2),
            conv_dw(1024, 1024, 1),
        )
        self.avg = nn.AdaptiveAvgPool2d((1,1))
        self.fc = nn.Linear(1024, 1000)

    def forward(self, x):
        x = self.stage1(x)
        x = self.stage2(x)
        x = self.stage3(x)
        x = self.avg(x)
        # x = self.model(x)
        x = x.view(-1, 1024)
        x = self.fc(x)
        return x

def mobilenet_v1(pretrained=False, progress=True,num_classes= 1000):
    model = MobileNetV1()
    if pretrained:
        print("mobilenet_v1 has no pretrained model")
    if num_classes != 1000:
        model.fc = nn.Linear(1024, num_classes)
    return model

if __name__ == "__main__":
    input = torch.randn([8,3,416,416])
    model = mobilenet_v1(num_classes= 2)
    out = model(input)
    print(out.shape)
    
'''
torch.Size([8, 2])

Process finished with exit code 0
'''

(3) MobileNetV2 pytorch

MobileNetV2在MobileNetV1的基础上，增加Inverted resblock模块儿。Inverted体现在对输入首先利用1x1卷积进行升维，然后利用3x3深度可分离卷积进行特征提取，然后再利用1x1卷积降维。resblock体现在输入和上一步输出相加。如下所示：


'''
（1）Inverted resblock
    Inverted：input--> conv2d(1*1 升维)+BN+ReLU6 --> DepthwiseConv2D(3*3)+BN+ReLU6--> conv2d(1*1 降维)+BN --> output
    resblock： output + input

（2）MobileNetV2
                 input.shape   expand_ratio   channels   times   strides
     conv2d        224^2*3          -            32        1        2
     bottleneck    112^2*32         1            16        1        1
     bottleneck    112^2*16         6            24        2        2
     bottleneck    56^2*24          6            32        3        2
     bottleneck    28^2*32          6            64        4        2
     bottleneck    28^2*64          6            96        3        1
     bottleneck    14^2*96          6            160       3        2
     bottleneck    7^2*160          6            320       1        1
     conv2d 1*1    7^2*320          -            1280      1        1
     avgpool7*7    7^2*1280         -            -         1        -
     conv2d 1*1    1*1*k            -            k         -     

'''


'''
MobileNetV2
'''

import torch
import torch.nn as nn
from torchvision.models.utils import load_state_dict_from_url


__all__ = ['MobileNetV2', 'mobilenet_v2']

model_urls = {
    'mobilenet_v2': 'https://download.pytorch.org/models/mobilenet_v2-b0353104.pth'}


def _make_divisible(v, divisor, min_value=None):
    if min_value is None:
        min_value = divisor
    new_v = max(min_value,
                int(v + divisor / 2) // divisor * divisor)
    if new_v < 0.9 * v:
        new_v += divisor
    return new_v


class ConvBNReLU(nn.Sequential):
    def __init__(self, in_planes, out_planes, kernel_size=3,
                 stride=1, groups=1):
        padding = (kernel_size - 1) // 2
        super(ConvBNReLU, self).__init__(
            nn.Conv2d(in_planes, out_planes, kernel_size,
                      stride, padding, groups=groups,
                      bias=False),
            nn.BatchNorm2d(out_planes),
            nn.ReLU6(inplace=True)
        )


class InvertedResidual(nn.Module):
    def __init__(self, inp, oup, stride, expand_ratio):
        super(InvertedResidual, self).__init__()
        self.stride = stride
        assert stride in [1, 2]

        hidden_dim = int(round(inp * expand_ratio))
        self.use_res_connect = self.stride == 1 and inp == oup

        layers = []
        if expand_ratio != 1:
            layers += [ConvBNReLU(inp, hidden_dim, kernel_size=1)]
        layers += [
            ConvBNReLU(hidden_dim, hidden_dim,
                       stride=stride, groups=hidden_dim),
            nn.Conv2d(hidden_dim, oup, 1, 1, 0, bias=False),
            nn.BatchNorm2d(oup)
        ]
        self.conv = nn.Sequential(*layers)

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


class MobileNetV2(nn.Module):
    def __init__(self, num_classes=1000, width_mult=1.0,
                 inverted_residual_setting=None,
                 round_nearest=8):
        super(MobileNetV2, self).__init__()
        block = InvertedResidual
        input_channel = 32
        last_channel = 1280

        if inverted_residual_setting is None:
            inverted_residual_setting = [
                [1, 16, 1, 1],
                [6, 24, 2, 2],
                [6, 32, 3, 2],
                [6, 64, 4, 2],
                [6, 96, 3, 1],
                [6, 160, 3, 2],
                [6, 320, 1, 1],
            ]
        if len(inverted_residual_setting) == 0 or len(
                inverted_residual_setting[0]) != 4:
            raise ValueError(
                "inverted_residual_setting should be non_empty"
                "or a 4-element list,got{}".format(
                    inverted_residual_setting))
        input_channel = _make_divisible(
            input_channel * width_mult, round_nearest)
        self.last_channel = _make_divisible(
            last_channel * max(1.0, width_mult),
            round_nearest)
        features = [ConvBNReLU(3, input_channel, stride=2)]
        for t, c, n, s in inverted_residual_setting:
            out_channel = _make_divisible(c * width_mult,
                                          round_nearest)
            for i in range(n):
                stride = s if i == 0 else 1
                features += [block(input_channel, out_channel,
                                   stride, expand_ratio=t)]
                input_channel = out_channel
        features += [ConvBNReLU(input_channel, self.last_channel,kernel_size=1)]
        self.features = nn.Sequential(*features)
        self.classifier = nn.Sequential(nn.Dropout(0.2),nn.Linear(self.last_channel,num_classes))

    def _initialize_weights(self):
        for m in self.modules():
            if isinstance(m, nn.Conv2d):
                nn.init.normal_(m.weight)
                # nn.init.uniform(m.weight)
                # nn.init.kaiming_normal(m.weight,mode='fan_out',nonlinearity='relu')
                if m.bias is not None:
                    nn.init.zeros_(m.bias)
            elif isinstance(m, nn.BatchNorm2d):
                nn.init.constant_(m.weight, 1)
                nn.init.zeros_(m.bias)
            elif isinstance(m, nn.Linear):
                nn.init.constant_(m.weight, 0.01)
                nn.init.zeros_(m.bias)

    def forward(self, x):
        x = self.features(x)
        x = x.mean([2, 3])
        x = self.classifier(x)
        return x


def mobilenet_v2(pretrained = False, progress = True, num_classes = 1000):
    model = MobileNetV2()
    if pretrained:
        state_dict = load_state_dict_from_url(model_urls['mobilenet_v2'],
                                              model_dir = './model_data',
                                              progress = progress)
        model.load_state_dict(state_dict,strict=False)
    if num_classes != 1000:
        model.classifier = nn.Sequential(
            nn.Dropout(0.2),
            nn.Linear(model.last_channel,num_classes))
    return model




if __name__ == '__main__':
    x = torch.randn([20, 3, 224, 224])
    # convBnReLU = ConvBNReLU(in_planes=3,out_planes=100)
    # convBnReLU(x).shape
    # output = InvertedResidual(3, 24, 2, 2)(x)
    # model = MobileNetV2()
    model = mobilenet_v2(num_classes = 20000)
    output = model(x)
    print(output.shape)
'''
torch.Size([20, 20000])

Process finished with exit code 0
'''

(4) MobileNetV3 pytorch

MobileNetV3的亮点是在InvertedResidual模块儿中添加了注意力机制SE，使用HS激活函数。


import torch.nn as nn
import math
import torch

def _make_divisible(v, divisor, min_value=None):
    if min_value is None:
        min_value = divisor
    new_v = max(min_value, int(v + divisor / 2) // divisor * divisor)
    # Make sure that round down does not go down by more than 10%.
    if new_v < 0.9 * v:
        new_v += divisor
    return new_v

class h_sigmoid(nn.Module):
    def __init__(self, inplace=True):
        super(h_sigmoid, self).__init__()
        self.relu = nn.ReLU6(inplace=inplace)

    def forward(self, x):
        return self.relu(x + 3) / 6


class h_swish(nn.Module):
    def __init__(self, inplace=True):
        super(h_swish, self).__init__()
        self.sigmoid = h_sigmoid(inplace=inplace)

    def forward(self, x):
        return x * self.sigmoid(x)


class SELayer(nn.Module):
    def __init__(self, channel, reduction=4):
        super(SELayer, self).__init__()
        self.avg_pool = nn.AdaptiveAvgPool2d(1)
        self.fc = nn.Sequential(
            nn.Linear(channel, _make_divisible(channel // reduction, 8)),
            nn.ReLU(inplace=True),
            nn.Linear(_make_divisible(channel // reduction, 8), channel),
            h_sigmoid()
        )

    def forward(self, x):
        b, c, _, _ = x.size()
        y = self.avg_pool(x).view(b, c)  # [b,c,h,w] --> [b,c,1,1] --> [b,c]
        y = self.fc(y).view(b, c, 1, 1)  # 降维--> 升维
        return x * y


def conv_3x3_bn(inp, oup, stride):
    return nn.Sequential(
        nn.Conv2d(inp, oup, 3, stride, 1, bias=False),
        nn.BatchNorm2d(oup),
        h_swish()
    )


def conv_1x1_bn(inp, oup):
    return nn.Sequential(
        nn.Conv2d(inp, oup, 1, 1, 0, bias=False),
        nn.BatchNorm2d(oup),
        h_swish()
    )


class InvertedResidual(nn.Module):
    def __init__(self, inp, hidden_dim, oup, kernel_size, stride, use_se, use_hs):
        super(InvertedResidual, self).__init__()
        assert stride in [1, 2]

        self.identity = stride == 1 and inp == oup

        if inp == hidden_dim:
            self.conv = nn.Sequential(
                # dw
                nn.Conv2d(hidden_dim, hidden_dim, kernel_size, stride, (kernel_size - 1) // 2, groups=hidden_dim, bias=False),
                nn.BatchNorm2d(hidden_dim),
                h_swish() if use_hs else nn.ReLU(inplace=True),
                # Squeeze-and-Excite
                SELayer(hidden_dim) if use_se else nn.Identity(),
                # pw-linear
                nn.Conv2d(hidden_dim, oup, 1, 1, 0, bias=False),
                nn.BatchNorm2d(oup),
            )
        else:
            self.conv = nn.Sequential(
                # pw
                nn.Conv2d(inp, hidden_dim, 1, 1, 0, bias=False),
                nn.BatchNorm2d(hidden_dim),
                h_swish() if use_hs else nn.ReLU(inplace=True),
                # dw
                nn.Conv2d(hidden_dim, hidden_dim, kernel_size, stride, (kernel_size - 1) // 2, groups=hidden_dim, bias=False),
                nn.BatchNorm2d(hidden_dim),
                # Squeeze-and-Excite
                SELayer(hidden_dim) if use_se else nn.Identity(),
                h_swish() if use_hs else nn.ReLU(inplace=True),
                # pw-linear
                nn.Conv2d(hidden_dim, oup, 1, 1, 0, bias=False),
                nn.BatchNorm2d(oup),
            )

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


class MobileNetV3(nn.Module):
    def __init__(self, num_classes=1000, width_mult=1.):
        self.num_classes = num_classes
        super(MobileNetV3, self).__init__()
        # setting of inverted residual blocks
        self.cfgs = [
            #` k, t, c, SE, HS, s
            [3,   1,  16, 0, 0, 1],
            [3,   4,  24, 0, 0, 2],
            [3,   3,  24, 0, 0, 1],
            [5,   3,  40, 1, 0, 2],
            [5,   3,  40, 1, 0, 1],
            [5,   3,  40, 1, 0, 1],
            [3,   6,  80, 0, 1, 2],
            [3, 2.5,  80, 0, 1, 1],
            [3, 2.3,  80, 0, 1, 1],
            [3, 2.3,  80, 0, 1, 1],
            [3,   6, 112, 1, 1, 1],
            [3,   6, 112, 1, 1, 1],
            [5,   6, 160, 1, 1, 2],
            [5,   6, 160, 1, 1, 1],
            [5,   6, 160, 1, 1, 1]
        ]

        input_channel = _make_divisible(16 * width_mult, 8)  # 16
        layers = [conv_3x3_bn(3, input_channel, 2)]

        block = InvertedResidual
        for k, t, c, use_se, use_hs, s in self.cfgs:
            output_channel = _make_divisible(c * width_mult, 8)
            exp_size = _make_divisible(input_channel * t, 8)
            layers.append(block(input_channel, exp_size, output_channel, k, s, use_se, use_hs))
            input_channel = output_channel
        self.features = nn.Sequential(*layers)

        self.conv = conv_1x1_bn(input_channel, exp_size)
        self.avgpool = nn.AdaptiveAvgPool2d((1, 1))
        output_channel = _make_divisible(1280 * width_mult, 8) if width_mult > 1.0 else 1280
        self.classifier = nn.Sequential(
            nn.Linear(exp_size, output_channel),
            h_swish(),
            nn.Dropout(0.2),
            nn.Linear(output_channel, num_classes),
        )

        self._initialize_weights()

    def forward(self, x):
        x = self.features(x)
        x = self.conv(x)
        x = self.avgpool(x)
        x = x.view(x.size(0), -1)
        x = self.classifier(x)
        return x

    def _initialize_weights(self):
        for m in self.modules():
            if isinstance(m, nn.Conv2d):
                n = m.kernel_size[0] * m.kernel_size[1] * m.out_channels
                m.weight.data.normal_(0, math.sqrt(2. / n))
                if m.bias is not None:
                    m.bias.data.zero_()
            elif isinstance(m, nn.BatchNorm2d):
                m.weight.data.fill_(1)
                m.bias.data.zero_()
            elif isinstance(m, nn.Linear):
                n = m.weight.size(1)
                m.weight.data.normal_(0, 0.01)
                m.bias.data.zero_()

def mobilenet_v3(pretrained=False, **kwargs):
    model = MobileNetV3(**kwargs)
    if pretrained:
        state_dict = torch.load('./model_data/mobilenetv3-large-1cd25616.pth')
        model.load_state_dict(state_dict, strict=True)
    if model.num_classes != 1000:
        in_channel = next(model.classifier[-1].parameters()).shape[1]
        model.classifier[-1] = nn.Linear(in_channel, model.num_classes)
    return model

if __name__ == '__main__':
    x = torch.randn([8,3,416,416])
    model = mobilenet_v3(num_classes=2)
    y = model(x)
    print(y.shape)
'''
torch.Size([8, 2])

Process finished with exit code 0
'''

'''
features(x)
Sequential(
  (0): Sequential(
    (0): Conv2d(3, 16, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)
    (1): BatchNorm2d(16, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    (2): h_swish(
      (sigmoid): h_sigmoid(
        (relu): ReLU6(inplace=True)
      )
    )
  )
  (1): InvertedResidual(
    (conv): Sequential(
      (0): Conv2d(16, 16, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=16, bias=False)
      (1): BatchNorm2d(16, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (2): ReLU(inplace=True)
      (3): Identity()
      (4): Conv2d(16, 16, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (5): BatchNorm2d(16, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    )
  )
  (2): InvertedResidual(
    (conv): Sequential(
      (0): Conv2d(16, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (2): ReLU(inplace=True)
      (3): Conv2d(64, 64, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), groups=64, bias=False)
      (4): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (5): Identity()
      (6): ReLU(inplace=True)
      (7): Conv2d(64, 24, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (8): BatchNorm2d(24, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    )
  )
  (3): InvertedResidual(
    (conv): Sequential(
      (0): Conv2d(24, 72, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (1): BatchNorm2d(72, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (2): ReLU(inplace=True)
      (3): Conv2d(72, 72, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=72, bias=False)
      (4): BatchNorm2d(72, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (5): Identity()
      (6): ReLU(inplace=True)
      (7): Conv2d(72, 24, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (8): BatchNorm2d(24, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    )
  )
  (4): InvertedResidual(
    (conv): Sequential(
      (0): Conv2d(24, 72, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (1): BatchNorm2d(72, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (2): ReLU(inplace=True)
      (3): Conv2d(72, 72, kernel_size=(5, 5), stride=(2, 2), padding=(2, 2), groups=72, bias=False)
      (4): BatchNorm2d(72, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (5): SELayer(
        (avg_pool): AdaptiveAvgPool2d(output_size=1)
        (fc): Sequential(
          (0): Linear(in_features=72, out_features=24, bias=True)
          (1): ReLU(inplace=True)
          (2): Linear(in_features=24, out_features=72, bias=True)
          (3): h_sigmoid(
            (relu): ReLU6(inplace=True)
          )
        )
      )
      (6): ReLU(inplace=True)
      (7): Conv2d(72, 40, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (8): BatchNorm2d(40, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    )
  )
  (5): InvertedResidual(
    (conv): Sequential(
      (0): Conv2d(40, 120, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (1): BatchNorm2d(120, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (2): ReLU(inplace=True)
      (3): Conv2d(120, 120, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2), groups=120, bias=False)
      (4): BatchNorm2d(120, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (5): SELayer(
        (avg_pool): AdaptiveAvgPool2d(output_size=1)
        (fc): Sequential(
          (0): Linear(in_features=120, out_features=32, bias=True)
          (1): ReLU(inplace=True)
          (2): Linear(in_features=32, out_features=120, bias=True)
          (3): h_sigmoid(
            (relu): ReLU6(inplace=True)
          )
        )
      )
      (6): ReLU(inplace=True)
      (7): Conv2d(120, 40, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (8): BatchNorm2d(40, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    )
  )
  (6): InvertedResidual(
    (conv): Sequential(
      (0): Conv2d(40, 120, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (1): BatchNorm2d(120, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (2): ReLU(inplace=True)
      (3): Conv2d(120, 120, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2), groups=120, bias=False)
      (4): BatchNorm2d(120, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (5): SELayer(
        (avg_pool): AdaptiveAvgPool2d(output_size=1)
        (fc): Sequential(
          (0): Linear(in_features=120, out_features=32, bias=True)
          (1): ReLU(inplace=True)
          (2): Linear(in_features=32, out_features=120, bias=True)
          (3): h_sigmoid(
            (relu): ReLU6(inplace=True)
          )
        )
      )
      (6): ReLU(inplace=True)
      (7): Conv2d(120, 40, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (8): BatchNorm2d(40, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    )
  )
  (7): InvertedResidual(
    (conv): Sequential(
      (0): Conv2d(40, 240, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (1): BatchNorm2d(240, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (2): h_swish(
        (sigmoid): h_sigmoid(
          (relu): ReLU6(inplace=True)
        )
      )
      (3): Conv2d(240, 240, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), groups=240, bias=False)
      (4): BatchNorm2d(240, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (5): Identity()
      (6): h_swish(
        (sigmoid): h_sigmoid(
          (relu): ReLU6(inplace=True)
        )
      )
      (7): Conv2d(240, 80, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (8): BatchNorm2d(80, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    )
  )
  (8): InvertedResidual(
    (conv): Sequential(
      (0): Conv2d(80, 200, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (1): BatchNorm2d(200, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (2): h_swish(
        (sigmoid): h_sigmoid(
          (relu): ReLU6(inplace=True)
        )
      )
      (3): Conv2d(200, 200, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=200, bias=False)
      (4): BatchNorm2d(200, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (5): Identity()
      (6): h_swish(
        (sigmoid): h_sigmoid(
          (relu): ReLU6(inplace=True)
        )
      )
      (7): Conv2d(200, 80, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (8): BatchNorm2d(80, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    )
  )
  (9): InvertedResidual(
    (conv): Sequential(
      (0): Conv2d(80, 184, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (1): BatchNorm2d(184, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (2): h_swish(
        (sigmoid): h_sigmoid(
          (relu): ReLU6(inplace=True)
        )
      )
      (3): Conv2d(184, 184, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=184, bias=False)
      (4): BatchNorm2d(184, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (5): Identity()
      (6): h_swish(
        (sigmoid): h_sigmoid(
          (relu): ReLU6(inplace=True)
        )
      )
      (7): Conv2d(184, 80, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (8): BatchNorm2d(80, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    )
  )
  (10): InvertedResidual(
    (conv): Sequential(
      (0): Conv2d(80, 184, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (1): BatchNorm2d(184, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (2): h_swish(
        (sigmoid): h_sigmoid(
          (relu): ReLU6(inplace=True)
        )
      )
      (3): Conv2d(184, 184, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=184, bias=False)
      (4): BatchNorm2d(184, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (5): Identity()
      (6): h_swish(
        (sigmoid): h_sigmoid(
          (relu): ReLU6(inplace=True)
        )
      )
      (7): Conv2d(184, 80, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (8): BatchNorm2d(80, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    )
  )
  (11): InvertedResidual(
    (conv): Sequential(
      (0): Conv2d(80, 480, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (1): BatchNorm2d(480, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (2): h_swish(
        (sigmoid): h_sigmoid(
          (relu): ReLU6(inplace=True)
        )
      )
      (3): Conv2d(480, 480, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=480, bias=False)
      (4): BatchNorm2d(480, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (5): SELayer(
        (avg_pool): AdaptiveAvgPool2d(output_size=1)
        (fc): Sequential(
          (0): Linear(in_features=480, out_features=120, bias=True)
          (1): ReLU(inplace=True)
          (2): Linear(in_features=120, out_features=480, bias=True)
          (3): h_sigmoid(
            (relu): ReLU6(inplace=True)
          )
        )
      )
      (6): h_swish(
        (sigmoid): h_sigmoid(
          (relu): ReLU6(inplace=True)
        )
      )
      (7): Conv2d(480, 112, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (8): BatchNorm2d(112, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    )
  )
  (12): InvertedResidual(
    (conv): Sequential(
      (0): Conv2d(112, 672, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (1): BatchNorm2d(672, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (2): h_swish(
        (sigmoid): h_sigmoid(
          (relu): ReLU6(inplace=True)
        )
      )
      (3): Conv2d(672, 672, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=672, bias=False)
      (4): BatchNorm2d(672, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (5): SELayer(
        (avg_pool): AdaptiveAvgPool2d(output_size=1)
        (fc): Sequential(
          (0): Linear(in_features=672, out_features=168, bias=True)
          (1): ReLU(inplace=True)
          (2): Linear(in_features=168, out_features=672, bias=True)
          (3): h_sigmoid(
            (relu): ReLU6(inplace=True)
          )
        )
      )
      (6): h_swish(
        (sigmoid): h_sigmoid(
          (relu): ReLU6(inplace=True)
        )
      )
      (7): Conv2d(672, 112, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (8): BatchNorm2d(112, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    )
  )
  (13): InvertedResidual(
    (conv): Sequential(
      (0): Conv2d(112, 672, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (1): BatchNorm2d(672, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (2): h_swish(
        (sigmoid): h_sigmoid(
          (relu): ReLU6(inplace=True)
        )
      )
      (3): Conv2d(672, 672, kernel_size=(5, 5), stride=(2, 2), padding=(2, 2), groups=672, bias=False)
      (4): BatchNorm2d(672, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (5): SELayer(
        (avg_pool): AdaptiveAvgPool2d(output_size=1)
        (fc): Sequential(
          (0): Linear(in_features=672, out_features=168, bias=True)
          (1): ReLU(inplace=True)
          (2): Linear(in_features=168, out_features=672, bias=True)
          (3): h_sigmoid(
            (relu): ReLU6(inplace=True)
          )
        )
      )
      (6): h_swish(
        (sigmoid): h_sigmoid(
          (relu): ReLU6(inplace=True)
        )
      )
      (7): Conv2d(672, 160, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (8): BatchNorm2d(160, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    )
  )
  (14): InvertedResidual(
    (conv): Sequential(
      (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): h_swish(
        (sigmoid): h_sigmoid(
          (relu): ReLU6(inplace=True)
        )
      )
      (3): Conv2d(960, 960, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2), groups=960, bias=False)
      (4): BatchNorm2d(960, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (5): SELayer(
        (avg_pool): AdaptiveAvgPool2d(output_size=1)
        (fc): Sequential(
          (0): Linear(in_features=960, out_features=240, bias=True)
          (1): ReLU(inplace=True)
          (2): Linear(in_features=240, out_features=960, bias=True)
          (3): h_sigmoid(
            (relu): ReLU6(inplace=True)
          )
        )
      )
      (6): h_swish(
        (sigmoid): h_sigmoid(
          (relu): ReLU6(inplace=True)
        )
      )
      (7): Conv2d(960, 160, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (8): BatchNorm2d(160, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    )
  )
  (15): InvertedResidual(
    (conv): Sequential(
      (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): h_swish(
        (sigmoid): h_sigmoid(
          (relu): ReLU6(inplace=True)
        )
      )
      (3): Conv2d(960, 960, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2), groups=960, bias=False)
      (4): BatchNorm2d(960, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (5): SELayer(
        (avg_pool): AdaptiveAvgPool2d(output_size=1)
        (fc): Sequential(
          (0): Linear(in_features=960, out_features=240, bias=True)
          (1): ReLU(inplace=True)
          (2): Linear(in_features=240, out_features=960, bias=True)
          (3): h_sigmoid(
            (relu): ReLU6(inplace=True)
          )
        )
      )
      (6): h_swish(
        (sigmoid): h_sigmoid(
          (relu): ReLU6(inplace=True)
        )
      )
      (7): Conv2d(960, 160, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (8): BatchNorm2d(160, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    )
  )
)




'''

'''
conv_1x1_bn(input_channel, exp_size):
(17) Sequential(
  (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): h_swish(
    (sigmoid): h_sigmoid(
      (relu): ReLU6(inplace=True)
    )
  )
)
'''


'''
nn.AdaptiveAvgPool2d((1, 1)):
(18) AdaptiveAvgPool2d(output_size=(1, 1))

'''

'''
classifier: 
(19) Sequential(
  (0): Linear(in_features=960, out_features=1280, bias=True)
  (1): h_swish(
    (sigmoid): h_sigmoid(
      (relu): ReLU6(inplace=True)
    )
  )
  (2): Dropout(p=0.2, inplace=False)
  (3): Linear(in_features=1280, out_features=1000, bias=True)
)


'''

(5) ResNet50 pytorch

ResNet50模型主要有两个模块儿：Conv Block和Identity Block。Conv Block负责下采样和提取特征，Identity Block是传统的残差结构，负责提取特征的扩展通道数。

'''
Conv Block：
    input --> Conv2d + BatchNorm + ReLU --> Conv2d + BatchNorm + ReLU--> Conv2d + BatchNorm --> o1
    input --> Conv2d + BatchNorm -->o2
    o1 + o2 --> ReLU --> output

Identity Block:
    input --> Conv2d + BatchNorm + ReLU --> Conv2d + BatchNorm + ReLU--> Conv2d + BatchNorm --> o1
    input + o2 --> ReLU --> output
    
ResNet50:
    input
    Zeropad
    Conv2d  + BatchNorm + ReLU + MaxPool
    Conv Block + Identity Block*2
    Conv Block + Identity Block*3
    Conv Block + Identity Block*5
    Conv Block + Identity Block*2
    AveragePooling2D
    Flatten
    output
'''


'''
Bottleneck根据downsample的输入确定是Conv Block还是Identity Block。downsample是由strides或者扩展输入通道与设定通道是否一致确定，downsample的内核是对特征层进行1*1，s=2 的下采样和BN组成。

Bottleneck的内核是(conv1*1 + conv3*3 + conv1*1 ) + residual

_make_layer的内核是Conv Block和Identity Block的组合。

ResNet的内核是其网络结构。

resnet50是实例化ResNet，加载参数，改变模型输出的类别数。
'''
import torch
import torch.nn as nn
from torchvision.models.utils import load_state_dict_from_url

model_urls = {
    'resnet50': 'https://download.pytorch.org/models/resnet50-19c8e357.pth',
}


def conv3x3(in_planes, out_planes, stride=1, groups=1, dilation=1):
    return nn.Conv2d(in_planes, out_planes, kernel_size=3, stride=stride,
                     padding=dilation, groups=groups, bias=False, dilation=dilation)

def conv1x1(in_planes, out_planes, stride=1):
    return nn.Conv2d(in_planes, out_planes, kernel_size=1, stride=stride, bias=False)

class Bottleneck(nn.Module):
    expansion = 4
    def __init__(self, inplanes, planes, stride=1, downsample=None, groups=1,
                 base_width=64, dilation=1, norm_layer=None):
        super(Bottleneck, self).__init__()
        if norm_layer is None:
            norm_layer = nn.BatchNorm2d
        width = int(planes * (base_width / 64.)) * groups
        # Both self.conv2 and self.downsample layers downsample the input when stride != 1
        self.conv1 = conv1x1(inplanes, width)
        self.bn1 = norm_layer(width)
        self.conv2 = conv3x3(width, width, stride, groups, dilation)
        self.bn2 = norm_layer(width)
        self.conv3 = conv1x1(width, planes * self.expansion)
        self.bn3 = norm_layer(planes * self.expansion)
        self.relu = nn.ReLU(inplace=True)
        self.downsample = downsample
        self.stride = stride

    def forward(self, x):
        identity = x

        out = self.conv1(x)
        out = self.bn1(out)
        out = self.relu(out)

        out = self.conv2(out)
        out = self.bn2(out)
        out = self.relu(out)

        out = self.conv3(out)
        out = self.bn3(out)

        if self.downsample is not None:
            identity = self.downsample(x)

        out += identity
        out = self.relu(out)

        return out


class ResNet(nn.Module):

    def __init__(self, block, layers, num_classes=1000, zero_init_residual=False,
                 groups=1, width_per_group=64, replace_stride_with_dilation=None,
                 norm_layer=None):
        super(ResNet, self).__init__()
        if norm_layer is None:
            norm_layer = nn.BatchNorm2d
        self._norm_layer = norm_layer

        self.inplanes = 64
        self.dilation = 1
        self.block = block
        if replace_stride_with_dilation is None:
            replace_stride_with_dilation = [False, False, False]

        if len(replace_stride_with_dilation) != 3:
            raise ValueError("replace_stride_with_dilation should be None "
                             "or a 3-element tuple, got {}".format(replace_stride_with_dilation))
        self.groups = groups
        self.base_width = width_per_group
        self.conv1 = nn.Conv2d(3, self.inplanes, kernel_size=7, stride=2, padding=3,
                               bias=False)
        self.bn1 = norm_layer(self.inplanes)
        self.relu = nn.ReLU(inplace=True)
        self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)
        self.layer1 = self._make_layer(block, 64, layers[0])
        self.layer2 = self._make_layer(block, 128, layers[1], stride=2,
                                       dilate=replace_stride_with_dilation[0])
        self.layer3 = self._make_layer(block, 256, layers[2], stride=2,
                                       dilate=replace_stride_with_dilation[1])
        self.layer4 = self._make_layer(block, 512, layers[3], stride=2,
                                       dilate=replace_stride_with_dilation[2])
        self.avgpool = nn.AdaptiveAvgPool2d((1, 1))
        self.fc = nn.Linear(512 * block.expansion, num_classes)

        for m in self.modules():
            if isinstance(m, nn.Conv2d):
                nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu')
            elif isinstance(m, (nn.BatchNorm2d, nn.GroupNorm)):
                nn.init.constant_(m.weight, 1)
                nn.init.constant_(m.bias, 0)

        if zero_init_residual:
            for m in self.modules():
                if isinstance(m, Bottleneck):
                    nn.init.constant_(m.bn3.weight, 0)

    def _make_layer(self, block, planes, blocks, stride=1, dilate=False):
        norm_layer = self._norm_layer
        downsample = None
        previous_dilation = self.dilation
        if dilate:
            self.dilation *= stride
            stride = 1
        if stride != 1 or self.inplanes != planes * block.expansion:
            downsample = nn.Sequential(
                conv1x1(self.inplanes, planes * block.expansion, stride),
                norm_layer(planes * block.expansion),
            )

        layers = []
        layers.append(block(self.inplanes, planes, stride, downsample, self.groups,
                            self.base_width, previous_dilation, norm_layer))
        self.inplanes = planes * block.expansion
        for _ in range(1, blocks):
            layers.append(block(self.inplanes, planes, groups=self.groups,
                                base_width=self.base_width, dilation=self.dilation,
                                norm_layer=norm_layer))

        return nn.Sequential(*layers)

    def forward(self, x):
        x = self.conv1(x)
        x = self.bn1(x)
        x = self.relu(x)
        x = self.maxpool(x)

        x = self.layer1(x)
        x = self.layer2(x)
        x = self.layer3(x)
        x = self.layer4(x)

        x = self.avgpool(x)
        x = torch.flatten(x, 1)
        x = self.fc(x)

        return x

def resnet50(pretrained=False, progress=True, num_classes=1000):
    model = ResNet(Bottleneck, [3, 4, 6, 3])
    if pretrained:
        state_dict = load_state_dict_from_url(model_urls['resnet50'], model_dir='./model_data',
                                              progress=progress)
        model.load_state_dict(state_dict)

    if num_classes != 1000:
        model.fc = nn.Linear(512 * model.block.expansion, num_classes)
    return model

if __name__ == '__main__':
    x = torch.randn([20,3,224,224])
    mod = resnet50(num_classes=2)
    output = mod(x)
    print(output.shape)
    
'''
torch.Size([20, 2])

Process finished with exit code 0
'''

对比发现VGG16（大约574MB）模型参数占内存最大，resnet50次之（97MB），mobilenetv3（22.1MB）、mobilenetv1（17MB）、mobilenetv2（14.2MB）模型参数量依次减少。

山居秋暝LS
关注
  • 2
    点赞
  • 踩
  • 19
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
vgg16_VGG16_
10-01
opencv，python版本，vgg16程序，希望对大家有用。
基于VGG(vgg13/vgg16)/ResNet(resnet34/resnet50)不同参数量级模型开发构建中草药图像识别分析系统，实验量化对比不同模型性能
Together_CZ的博客
01-27 2444
基于VGG(vgg13/vgg16)/ResNet(resnet34/resnet50)不同参数量级模型开发构建中草药图像识别分析系统，实验量化对比不同模型性能
深度学习--CNN应用--VGG16网络和ResNet18网络
ssheudjbdndnjd的博客
04-18 1423
VGG论文大家有兴趣的可以去研读一下。首先呢，我们先简单了解一下VGG网络的来源自2012年AlexNet在lmageNet图片分类比赛中大获成功以来，关于深度神经网络的研究又一次如火如茶般进行;VGGNet 是由牛津大学视觉几何小组 (Visual Geometry Group,VGG)提出的一种深层卷积网络结构，他们以 7.32% 的错误率赢得了 2014年 ILSVRC 分类任务的亚军(冠军由 GoogLeNet 以 6.65% 的错误率夺得)
深度学习之基于VGG16与ResNet50实现鸟类识别
starlet_kiss的博客
08-17 5849
鸟类识别在之前做过，但是效果特别差。而且ResNet50的效果直接差到爆炸，这次利用VGG16与ResNet50的官方模型进行鸟类识别。 1.导入库 import tensorflow as tf import numpy as np import matplotlib.pyplot as plt import os,pathlib,PIL from tensorflow.keras import layers,models,Sequential,Input,Model from tensorflow.ke
【深度学习网络结构】 深度学习——卷积神经网络 的经典网络（LeNet-5、AlexNet、ZFNet、VGG-16、GoogLeNet、ResNet）
小C的博客
09-09 7653
【深度学习网络结构】 深度学习——卷积神经网络 的经典网络（LeNet-5、AlexNet、ZFNet、VGG-16、GoogLeNet、ResNet） 【声明】本文的主要内容来自博客园，链接为https://www.cnblogs.com/guoyaohua/p/8534077.html，在此基础上删改与补充 【编辑时间：2018.09.07】 【完成时间：2018.09.09】   ...
手把手带你从0完成医疗行业影像图像检测三大经典模型InceptionV3-RestNet50-VGG16（附python源代码及数据库）——改变世界经典人工智能项目实战（一）手把手教学迁移学习
小胡说人工智能的博客
03-29 988
如果你想使用现在最火的ChatGPT来训练属于你的专属ChatGPT模型，那你千万不能错过这篇文章。迁移学习是机器学习领域中的一种重要方法，它通过利用先前的学习经验来提高当前任务的性能。本文通过3个经典的模型：InceptionV3-RestNet50-VGG16作为示例，为大家从0开始搭建了医疗影像行业迁移学习网络，并获取到了较好的准确度与结果一致性。而掌握好迁移学习的基础知识和应用，你就能通过**模型微调（也称迁移学习）**，调用ChatGPT接口加上你的训练集去训练你的模型了。
【CNN优化加速】02轻量化模型：MobileNet v1-v3、ShuffleNet v1-v2、EfficientNet v1-v2简介
ShiTianlei的博客
09-28 1902
经典的轻量化网络简介【持续更新】
VGG-PyTorch-master_vgg16模型_VGG16pytorch_vgg16pytorchcode_
10-01
vgg16代码，最简单pytorch版本，容易看懂，易上手，按照论文敲的
基于vgg网络和Resnet的白盒攻击pytorch实现项目源码.zip
最新发布
05-09
基于vgg网络和Resnet的白盒攻击pytorch实现项目源码.zip主要实现了FGSM、I-FGSM和MI-FGSM三种算法攻击VGG-16网络和Resnet-50网络。 基于vgg网络和Resnet的白盒攻击pytorch实现项目源码.zip主要实现了FGSM、I-FGSM...
深度学习作业-基于resnet50和vgg16网络pytorch框架实现猫狗分类完整源码+代码注释+实验报告.zip
12-14
深度学习作业_基于resnet50和vgg16网络pytorch框架实现猫狗分类完整源码+代码注释+实验报告.zip 猫狗分类，使用Kaggle猫狗分类的原始数据集，实现模型最终的准确率达到90%及以上。本实验的目的： 为了进一步掌握...
deep learning模型包含VGG16/VGG19/RESNET50 python源代码
03-23
deep learning经典模型的搭建，包括vgg16，vgg19，resnet50，都使用python源代码，并有详细注释，可以显示模型结构，适合初学者入门了解
py-R-FCN的ResNet50和ResNet101预训练模型
02-21
就是两个预训练模型，分别是ResNet-50的和ResNet-101的预训练模型。直接下载解压就行了。对了，是原版的RFCN哦，就是Caffe+Python的，不是tensorflow的model。
vgg16_weights_th_dim_ordering_th_kernels_notop.h5
08-05
vgg16 cnn theano
resnet50二分类
11-01
resnet50二分类/recall_precision评价 包括数据读取，处理等函数
VGGFace2-pytorch:基于'VGGFace2的PyTorch人脸识别器
05-12
基于“ VGGFace2：用于识别跨姿势和年龄的面部表情的数据集”的PyTorch面部表情识别器。 此仓库实现了培训和测试模型，并基于VGGFace2 [1]的模型构建了特征提取器。 是从[1]的作者提供的转换而来的。 数据集 要...
【深度学习】经典的卷积神经网络模型介绍（LeNet、AlexNet、VGGNet、GoogLeNet、ResNet和MobileNet）
热门推荐
点赞的都能无bug通过！
03-17 3万+
经典的卷积神经网络模型介绍卷积神经网络简介一、LeNet1、INPUT层-输入层2、C1层-卷积层3、S2层-池化层（下采样层）4、C3层-卷积层5、S4层-池化层（下采样层）6、C5层-卷积层7、F6层-全连接层二、AlexNet1、AlexNet特点2、ReLu作为激活函数3、数据增强4、层叠池化5、局部相应归一化6、Dropout7、Alex网络结构8、AlexNet参数数量三、VGG net1、VGG的特点2、VGG网络结构3、VGG优缺点四、GoogLeNet1、GoogLeNet Incepet
一文读懂最近流行的CNN架构（附学习资料）
数据派THU
01-14 3468
来源： 机器学习算法全栈工程师本文长度为4259字，建议阅读6分钟本文为你介绍CNN架构，包括ResNet, AlexNet, VGG, Inception。本文翻译自ResNet, AlexNet, VGG, Inception: Understanding various architectures of Convolutional Networks，原作者保留版权。http://cv-tri
神经网络学习小记录55——Keras搭建常见分类网络平台（VGG16、MobileNet、ResNet50）
Bubbliiiing的学习小课堂
01-26 1万+
神经网络学习小记录54——Keras搭建常见分类网络平台（VGG16、MobileNet、ResNet50）学习前言源码下载分类网络的常见形式分类网络介绍1、VGG16网络介绍2、MobilenetV1网络介绍3、ResNet50网络介绍a、什么是残差网络b、什么是ResNet50模型分类网络的训练1、LOSS介绍2、利用分类网络进行训练 学习前言 才发现做了这么多的博客和视频，居然从来没有做过分类网络，做一个科学的分类网络，对身体好。 源码下载 https://github.com/bubbliiiin
关于Resnet50和ResNeXt50的参数量的简单计算（只考虑卷积层和全连接层）
qq_36401512的博客
04-20 2万+
主要是我想知道ResNeXt50按cardinality方式每组是不是共享了参数？ 参考一张图：https://www.zhihu.com/question/323424817 上面已经写了Resnet50和ResNeXt50的参数量 Resnet50的参数量： 1.conv1： 3（jpg输入三通道）*64（输出64通道）*7*7（卷积核参数）=9048 2.conv2：(64*...
VGG16网络和ResNet50模型体积、参数量、计算量对比
06-09
VGG16和ResNet50是两种常见的卷积神经网络模型，它们的体积、参数量和计算量有所不同。 以TensorFlow为例，使用TensorFlow Hub提供的预训练模型，VGG16模型大小约为528MB，ResNet50模型大小约为98MB。在参数量方面，VGG16模型共有138,357,544个参数，而ResNet50模型共有25,636,712个参数。计算量方面，VGG16模型需要进行15,300亿次浮点运算，而ResNet50模型需要进行3,800亿次浮点运算。 需要注意的是，这些数值仅作为参考，实际情况可能会因为不同的实现和框架等因素而有所不同。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值