OpenPose MobileNet V1 作为Backbone的模型结构（1）

最新推荐文章于 2024-06-14 09:51:36 发布
最新推荐文章于 2024-06-14 09:51:36 发布
阅读量1.6k 收藏 16
点赞数 2
分类专栏： 姿态估计 文章标签： OpenPose
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/flyfish1986/article/details/104412406
版权

OpenPose MobileNet V1 作为Backbone的模型结构（1）

MobileNet V1 的改造

flyfish

论文地址
论文中提到的源码地址
深度可分离卷积是如何减少计算量的
OpenPose MobileNet V1 作为Backbone的模型结构（1） MobileNet V1 的改造
OpenPose MobileNet V1 作为Backbone的模型结构（2） Initial Stage和Refinement Stage的优化
OpenPose MobileNet V1 作为Backbone的模型结构（3） Branch的合并

原来的MobileNet v1，经过改造之后，名字改为Dilated MobileNet v1
VGG作为Backbone的模型结构，OpenPose 是直接取一些层不做更改;MobileNet V1 作为Backbone的模型结构是，OpenPose做少许更改
看下面原始的MobileNetV1，再做说明是如何更改的

MobileNet_Original(
  (model): Sequential(
    (0): Sequential(
      (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): ReLU(inplace=True)
    )
    (1): Sequential(
      (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): ReLU(inplace=True)
      (3): Conv2d(32, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (4): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (5): ReLU(inplace=True)
    )
    (2): Sequential(
      (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), groups=64, bias=False)
      (1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (2): ReLU(inplace=True)
      (3): Conv2d(64, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (4): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (5): ReLU(inplace=True)
    )
    (3): Sequential(
      (0): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=128, bias=False)
      (1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (2): ReLU(inplace=True)
      (3): Conv2d(128, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (4): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (5): ReLU(inplace=True)
    )
    (4): Sequential(
      (0): Conv2d(128, 128, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), groups=128, bias=False)
      (1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (2): ReLU(inplace=True)
      (3): Conv2d(128, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (4): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (5): ReLU(inplace=True)
    )
    (5): Sequential(
      (0): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=256, bias=False)
      (1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (2): ReLU(inplace=True)
      (3): Conv2d(256, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (4): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (5): ReLU(inplace=True)
    )
    (6): Sequential(
      (0): Conv2d(256, 256, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), groups=256, bias=False)
      (1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (2): ReLU(inplace=True)
      (3): Conv2d(256, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (4): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (5): ReLU(inplace=True)
    )
    (7): Sequential(
      (0): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=512, bias=False)
      (1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (2): ReLU(inplace=True)
      (3): Conv2d(512, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (4): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (5): ReLU(inplace=True)
    )
    (8): Sequential(
      (0): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=512, bias=False)
      (1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (2): ReLU(inplace=True)
      (3): Conv2d(512, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (4): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (5): ReLU(inplace=True)
    )
    (9): Sequential(
      (0): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=512, bias=False)
      (1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (2): ReLU(inplace=True)
      (3): Conv2d(512, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (4): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (5): ReLU(inplace=True)
    )
    (10): Sequential(
      (0): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=512, bias=False)
      (1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (2): ReLU(inplace=True)
      (3): Conv2d(512, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (4): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (5): ReLU(inplace=True)
    )
    (11): Sequential(
      (0): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=512, bias=False)
      (1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (2): ReLU(inplace=True)
      (3): Conv2d(512, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (4): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (5): ReLU(inplace=True)
    )
    (12): Sequential(
      (0): Conv2d(512, 512, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), groups=512, bias=False)
      (1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (2): ReLU(inplace=True)
      (3): Conv2d(512, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (4): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (5): ReLU(inplace=True)
    )
    (13): Sequential(
      (0): Conv2d(1024, 1024, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=1024, bias=False)
      (1): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (2): ReLU(inplace=True)
      (3): Conv2d(1024, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (4): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (5): ReLU(inplace=True)
    )
    (14): AvgPool2d(kernel_size=7, stride=7, padding=0)
  )
  (fc): Linear(in_features=1024, out_features=1000, bias=True)
)

更改1
去除，12,13,14平均池化层和最后的15全连接层

   (12): Sequential(
      (0): Conv2d(512, 512, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), groups=512, bias=False)
      (1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (2): ReLU(inplace=True)
      (3): Conv2d(512, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (4): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (5): ReLU(inplace=True)
    )
    (13): Sequential(
      (0): Conv2d(1024, 1024, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=1024, bias=False)
      (1): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (2): ReLU(inplace=True)
      (3): Conv2d(1024, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (4): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (5): ReLU(inplace=True)
    )
    (14): AvgPool2d(kernel_size=7, stride=7, padding=0)
  )
  (fc): Linear(in_features=1024, out_features=1000, bias=True)

再看6和7

(6): Sequential(
  (0): Conv2d(256, 256, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), groups=256, bias=False)
  (1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
  (2): ReLU(inplace=True)
  (3): Conv2d(256, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)
  (4): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
  (5): ReLU(inplace=True)
)
(7): Sequential(
  (0): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=512, bias=False)
  (1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
  (2): ReLU(inplace=True)
  (3): Conv2d(512, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)
  (4): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
  (5): ReLU(inplace=True)
)

(6)(0)的stride由stride=(2, 2)更改为 stride=(1, 1)
更改之后是

 (6): Sequential(
      (0): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=256, bias=False)

(7)(0)使用了空洞卷积（dilated convolution）https://arxiv.org/abs/1511.07122

(7): Sequential(
      (0): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), groups=512, bias=False)

原始论文是这样说的

To save spatial resolution and reuse backbone weights we use dilated convolution . Stride of conv4_2/dw layer was removed and dilation parameter value was set to 2 for succeeding conv5_1/dw layer to preserve receptive field. So we use all layers till conv5_5 block.
Addition of conv5_6 block improves the accuracy, but at cost of performance. We also tried more lightweight backbone MobileNet v2, however it did not show good result, see Table 4.

为了节省空间分辨率和重复使用backbone权重，我们使用膨胀卷积。去除Conv4_2/dw层的步幅，并将随后的Conv5_1/dw层的dilation参数值设置为2，以保留感受野。因此，我们使用所有的层，直到conv5_5 block。加入Conv5_6 block提高了精度，但以牺牲性能为代价。我们也尝试了更轻量级的主干MobileNet v2，但是没有显示出很好的效果，请参见表4。
在这里插入图片描述

Conv4_2/dw对应(6)(0)
Conv5_1/dw(7)(0)
表达的意思就是

conv(     3,  32, stride=2, bias=False),
conv_dw( 32,  64),
conv_dw( 64, 128, stride=2),
conv_dw(128, 128),
conv_dw(128, 256, stride=2),
conv_dw(256, 256),
conv_dw(256, 512),  # conv4_2
conv_dw(512, 512, dilation=2, padding=2),
conv_dw(512, 512),
conv_dw(512, 512),
conv_dw(512, 512),
conv_dw(512, 512)   # conv5_5

详细些

 conv(     3,  32, stride=2, bias=False),    # conv+BN+ReLU
 conv_dw( 32,  64),                           			 # dw_conv(in,in, stride)+BN+ReLU + conv(in,out)+BN+ReLU
 conv_dw( 64, 128, stride=2),                 # dw_conv(in,in, stride)+BN+ReLU + conv(in,out)+BN+ReLU
 conv_dw(128, 128),                         		 # dw_conv(in,in, stride)+BN+ReLU + conv(in,out)+BN+ReLU
 conv_dw(128, 256, stride=2),                # dw_conv(in,in, stride)+BN+ReLU + conv(in,out)+BN+ReLU
 conv_dw(256, 256),                         			 # dw_conv(in,in, stride)+BN+ReLU + conv(in,out)+BN+ReLU
 conv_dw(256, 512),         # conv4_2        # dw_conv(in,in, stride)+BN+ReLU + conv(in,out)+BN+ReLU
 conv_dw(512, 512, dilation=2, padding=2),   # dw_conv(in,in, stride)+BN+ReLU + conv(in,out)+BN+ReLU
 conv_dw(512, 512),                     	     # dw_conv(in,in, stride)+BN+ReLU + conv(in,out)+BN+ReLU
 conv_dw(512, 512),                         		 # dw_conv(in,in, stride)+BN+ReLU + conv(in,out)+BN+ReLU
 conv_dw(512, 512),                          		# dw_conv(in,in, stride)+BN+ReLU + conv(in,out)+BN+ReLU
 conv_dw(512, 512)   # conv5_5               # dw_conv(in,in, stride)+BN+ReLU + conv(in,out)+BN+ReLU

VGG的OpenPose作者在VGG后加的

  (23): Conv2d(512, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
  (24): ReLU(inplace=True)
  (25): Conv2d(256, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
  (26): ReLU(inplace=True)

在MobileNet v1的OpenPose 作者改为 减少了channel数，从256减到128. 使用3个深度可分离卷积（depthwise separable conv）代替。

(cpm): Cpm(
    (align): Sequential(
      (0): Conv2d(512, 128, kernel_size=(1, 1), stride=(1, 1))
      (1): ReLU(inplace=True)
    )
    (trunk): Sequential(
      (0): Sequential(
        (0): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=128, bias=False)
        (1): ELU(alpha=1.0, inplace=True)
        (2): Conv2d(128, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (3): ELU(alpha=1.0, inplace=True)
      )
      (1): Sequential(
        (0): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=128, bias=False)
        (1): ELU(alpha=1.0, inplace=True)
        (2): Conv2d(128, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (3): ELU(alpha=1.0, inplace=True)
      )
      (2): Sequential(
        (0): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=128, bias=False)
        (1): ELU(alpha=1.0, inplace=True)
        (2): Conv2d(128, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (3): ELU(alpha=1.0, inplace=True)
      )
    )
    (conv): Sequential(
      (0): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
      (1): ReLU(inplace=True)
    )
  )

Backbone结构更改完了，还有Head的改进即包括Initial stage 和 Refinement Stage

整体结构如下

MobileNetV1_OpenPose(
  (model): Sequential(
    (0): Sequential(
      (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): ReLU(inplace=True)
    )
    (1): Sequential(
      (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): ReLU(inplace=True)
      (3): Conv2d(32, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (4): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (5): ReLU(inplace=True)
    )
    (2): Sequential(
      (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), groups=64, bias=False)
      (1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (2): ReLU(inplace=True)
      (3): Conv2d(64, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (4): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (5): ReLU(inplace=True)
    )
    (3): Sequential(
      (0): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=128, bias=False)
      (1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (2): ReLU(inplace=True)
      (3): Conv2d(128, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (4): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (5): ReLU(inplace=True)
    )
    (4): Sequential(
      (0): Conv2d(128, 128, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), groups=128, bias=False)
      (1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (2): ReLU(inplace=True)
      (3): Conv2d(128, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (4): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (5): ReLU(inplace=True)
    )
    (5): Sequential(
      (0): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=256, bias=False)
      (1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (2): ReLU(inplace=True)
      (3): Conv2d(256, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (4): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (5): ReLU(inplace=True)
    )
    (6): Sequential(
      (0): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=256, bias=False)
      (1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (2): ReLU(inplace=True)
      (3): Conv2d(256, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (4): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (5): ReLU(inplace=True)
    )
    (7): Sequential(
      (0): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), groups=512, bias=False)
      (1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (2): ReLU(inplace=True)
      (3): Conv2d(512, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (4): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (5): ReLU(inplace=True)
    )
    (8): Sequential(
      (0): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=512, bias=False)
      (1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (2): ReLU(inplace=True)
      (3): Conv2d(512, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (4): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (5): ReLU(inplace=True)
    )
    (9): Sequential(
      (0): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=512, bias=False)
      (1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (2): ReLU(inplace=True)
      (3): Conv2d(512, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (4): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (5): ReLU(inplace=True)
    )
    (10): Sequential(
      (0): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=512, bias=False)
      (1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (2): ReLU(inplace=True)
      (3): Conv2d(512, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (4): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (5): ReLU(inplace=True)
    )
    (11): Sequential(
      (0): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=512, bias=False)
      (1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (2): ReLU(inplace=True)
      (3): Conv2d(512, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (4): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (5): ReLU(inplace=True)
    )
  )
  (cpm): Cpm(
    (align): Sequential(
      (0): Conv2d(512, 128, kernel_size=(1, 1), stride=(1, 1))
      (1): ReLU(inplace=True)
    )
    (trunk): Sequential(
      (0): Sequential(
        (0): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=128, bias=False)
        (1): ELU(alpha=1.0, inplace=True)
        (2): Conv2d(128, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (3): ELU(alpha=1.0, inplace=True)
      )
      (1): Sequential(
        (0): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=128, bias=False)
        (1): ELU(alpha=1.0, inplace=True)
        (2): Conv2d(128, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (3): ELU(alpha=1.0, inplace=True)
      )
      (2): Sequential(
        (0): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=128, bias=False)
        (1): ELU(alpha=1.0, inplace=True)
        (2): Conv2d(128, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (3): ELU(alpha=1.0, inplace=True)
      )
    )
    (conv): Sequential(
      (0): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
      (1): ReLU(inplace=True)
    )
  )
  (initial_stage): InitialStage(
    (trunk): Sequential(
      (0): Sequential(
        (0): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
        (1): ReLU(inplace=True)
      )
      (1): Sequential(
        (0): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
        (1): ReLU(inplace=True)
      )
      (2): Sequential(
        (0): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
        (1): ReLU(inplace=True)
      )
    )
    (heatmaps): Sequential(
      (0): Sequential(
        (0): Conv2d(128, 512, kernel_size=(1, 1), stride=(1, 1))
        (1): ReLU(inplace=True)
      )
      (1): Sequential(
        (0): Conv2d(512, 19, kernel_size=(1, 1), stride=(1, 1))
      )
    )
    (pafs): Sequential(
      (0): Sequential(
        (0): Conv2d(128, 512, kernel_size=(1, 1), stride=(1, 1))
        (1): ReLU(inplace=True)
      )
      (1): Sequential(
        (0): Conv2d(512, 38, kernel_size=(1, 1), stride=(1, 1))
      )
    )
  )
  (refinement_stages): ModuleList(
    (0): RefinementStage(
      (trunk): Sequential(
        (0): RefinementStageBlock(
          (initial): Sequential(
            (0): Conv2d(185, 128, kernel_size=(1, 1), stride=(1, 1))
            (1): ReLU(inplace=True)
          )
          (trunk): Sequential(
            (0): Sequential(
              (0): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
              (1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
              (2): ReLU(inplace=True)
            )
            (1): Sequential(
              (0): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2))
              (1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
              (2): ReLU(inplace=True)
            )
          )
        )
        (1): RefinementStageBlock(
          (initial): Sequential(
            (0): Conv2d(128, 128, kernel_size=(1, 1), stride=(1, 1))
            (1): ReLU(inplace=True)
          )
          (trunk): Sequential(
            (0): Sequential(
              (0): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
              (1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
              (2): ReLU(inplace=True)
            )
            (1): Sequential(
              (0): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2))
              (1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
              (2): ReLU(inplace=True)
            )
          )
        )
        (2): RefinementStageBlock(
          (initial): Sequential(
            (0): Conv2d(128, 128, kernel_size=(1, 1), stride=(1, 1))
            (1): ReLU(inplace=True)
          )
          (trunk): Sequential(
            (0): Sequential(
              (0): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
              (1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
              (2): ReLU(inplace=True)
            )
            (1): Sequential(
              (0): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2))
              (1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
              (2): ReLU(inplace=True)
            )
          )
        )
        (3): RefinementStageBlock(
          (initial): Sequential(
            (0): Conv2d(128, 128, kernel_size=(1, 1), stride=(1, 1))
            (1): ReLU(inplace=True)
          )
          (trunk): Sequential(
            (0): Sequential(
              (0): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
              (1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
              (2): ReLU(inplace=True)
            )
            (1): Sequential(
              (0): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2))
              (1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
              (2): ReLU(inplace=True)
            )
          )
        )
        (4): RefinementStageBlock(
          (initial): Sequential(
            (0): Conv2d(128, 128, kernel_size=(1, 1), stride=(1, 1))
            (1): ReLU(inplace=True)
          )
          (trunk): Sequential(
            (0): Sequential(
              (0): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
              (1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
              (2): ReLU(inplace=True)
            )
            (1): Sequential(
              (0): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2))
              (1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
              (2): ReLU(inplace=True)
            )
          )
        )
      )
      (heatmaps): Sequential(
        (0): Sequential(
          (0): Conv2d(128, 128, kernel_size=(1, 1), stride=(1, 1))
          (1): ReLU(inplace=True)
        )
        (1): Sequential(
          (0): Conv2d(128, 19, kernel_size=(1, 1), stride=(1, 1))
        )
      )
      (pafs): Sequential(
        (0): Sequential(
          (0): Conv2d(128, 128, kernel_size=(1, 1), stride=(1, 1))
          (1): ReLU(inplace=True)
        )
        (1): Sequential(
          (0): Conv2d(128, 38, kernel_size=(1, 1), stride=(1, 1))
        )
      )
    )
  )
)
西笑生
关注
  • 2
    点赞
  • 踩
  • 16
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 2
    评论
专栏目录
Mobilenet四代网络模型架构
qq_52053775的博客
05-12 190
Mobilenet是一个用于移动端和嵌入式的神经网络，其核心思想是采用深度可分离卷积替代标准的卷积，以减少参数和计算量，同时也可对网络通道数和分辨率采用缩放策略。Mobilenet v2仍然是基于深度可分离卷积，使用倒残差结构解决深度可分离卷积中的窄边非线性激活的问题。MobileNetV3在 Mobilenet v2的基础上进一步引入了注意力机制SE模块，并使用了H-Swish激活函数。（1）现有问题移动设备的计算能力有限，同时需要处理实时交互体验，这要求模型既要高效也要具备高准确性。
通俗易懂的YOLO系列（从V1到V5）模型解读！
08-19
1. 引入了EfficientNet作为 backbone 网络，提高了模型的检测精度。 2. 使用了 BiFPN（Bidirectional Feature Pyramid Network）来融合不同尺度的特征，提高了模型的检测精度。 3. 引入了anchor-free机制，提高了...
human-pose-estimation-opencv:使用OpenPose MobileNet在OpenCV中执行人体姿势估计
05-13
人姿势估计opencv 使用OpenPose MobileNet在OpenCV中执行人体姿势估计 如何使用 使用网络摄像头进行测试 python openpose.py 用图像测试 python openpose.py --input image.jpg 使用--thr增加置信度阈值 python openpose.py --input image.jpg --thr 0.5 笔记： 我修改了以使用由提供的Tensorflow MobileNet Model ，而不是来自CMU OpenPose的Caffe Model 。 来自OpenCV example的原始openpose.py仅使用超过200MB的Caffe Model ，而Mobilenet只有7MB。 基本上，我们需要更改cv.dnn.blobFromImage并使用out = out[:, :19, :, :] cv
OpenPose MobileNet V1 作为Backbone的模型结构（3）
flyfish
02-21 974
OpenPose MobileNet V1 作为Backbone的模型结构（3） 两个Branch的合并 flyfish 论文原文 To produce new estimation of keypoint heatmaps and pafs the refinement stage takes features from backbone concatenated with previous e...
使用OpenPose MobileNet在OpenCV中执行人体姿势估计
最新发布
qq1744828575的博客
06-14 693
一、项目背景与意义人体姿势估计在计算机视觉领域有着广泛的应用，如体育分析、医疗健康、人机交互等。OpenPose是一个强大的人体姿态估计库，它基于深度学习技术，能够实时、准确地检测图像或视频中的人体关键点，如头、颈、肩、肘、腕等。而MobileNet是一个轻量级的深度学习模型，适用于移动和嵌入式设备。将OpenPose与MobileNet结合，在OpenCV中执行人体姿势估计，可以实现高效、准确且适用于多种平台的人体姿态识别[1][2][3]。二、技术框架与工具。
OpenPose MobileNet V1 作为Backbone的模型结构（2）
flyfish
02-21 1749
OpenPose MobileNet V1 作为Backbone的模型结构（2） Initial Stage和Refinement Stage的优化 flyfish 论文地址 论文中提到的源码地址 深度可分离卷积是如何减少计算量的 OpenPose MobileNet V1 作为Backbone的模型结构（1） OpenPose MobileNet V1 作为Backbone的模型结构（2） ...
CV之IPE之MobiLenet：基于openpose利用CMU/MobilenetV2算法实现对多人体姿态估计检测(以勒布朗詹姆斯扣篮姿态为例)案例应用
近期请国内外头部出版社可尽快私信博主！——心比天高，仗剑走天涯，保持热爱，奔赴向梦想！低调，谦虚，自律，反思，成长，还算是比较正能量的博主，公益免费传播……内心特别想在AI界做出一些可以推进历史进程影响力的东西(兴趣使然，有点小情怀，也有点使命感呀)…
12-16 7012
CV之IPE之MobiLenet：基于openpose利用CMU/MobilenetV2算法实现对多人体姿态估计检测(以勒布朗詹姆斯扣篮姿态为例)案例应用。
OpenPose VGG作为Backbone的模型结构
flyfish
02-21 1104
OpenPose VGG作为backbone的模型结构 flyfish 取VGG的序号0到22 (23): Conv2d(512, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) (24): ReLU(inplace=True) (25): Conv2d(256, 128, kernel_size=(3, 3), stri...
OpenPose TF版backbone使用的VGG16还是VGG19
01-06
OpenPose TF版backbone使用的VGG16还是VGG19 flyfish 如何分辨backbone使用的VGG16还是VGG19？ 看第二个最大池化层和第三个最大池化层之间的conv3-256 如果conv3-256的个数是3，则是VGG-16 如果conv3-256的个数是4，...
backbone-proxy:Backbone 的模型代理
06-21
Backbone 的模型代理。 在具有不同关注点的多个组件（例如视图）之间共享单个模型实例是一种常见模式的应用程序中特别有用。 在这种情况下，多个组件需要引用相同的模型封装状态，这禁止了模型行为的特殊化。 此外...
YOLOX骨干网backbone-PAFPN网络结构示1
08-04
YOLOX骨干网Backbone-PAFPN网络结构示意图 在计算机视觉和机器学习领域，YOLOX是一个基于深度学习的目标检测算法，骨干网Backbone-PAFPN网络结构是其核心组件之一。本文将详细介绍YOLOX骨干网Backbone-PAFPN网络...
MobileNetV2-PoseEstimation：基于Tensorflow的快速姿势估计。 OpenVINO，Tensorflow Lite，NCS，NCS2 + Python
02-06
MobileNetV2-PoseEstimation [注意] RraspberryPi + NCS2的行为非常不稳定。 [注意] Tensorflow Lite + CPU的行为不稳定。 [警告] 2019年5月6日，Google Edge TPU程序和模型正在建设中。 [信息] 2020年6月8日，我正在极大地调整Tensorflow Lite模型的性能。 介绍 ildoonet的成就给该存储库带来了自己的实现。 谢谢 。 我将仅使用CPU使他的实现更快。 环境 Ubuntu 16.04 x86_64 USB相机 神经计算棒2（NCS2） Google Edge TPU Py
openpose各种骨架提取模型文件（全）20200504
05-04
手势识别系列文章之基于单目视觉的openpose手部骨架提取，文章链接：https://blog.csdn.net/kissgoodbye2012/article/details/105892907
Openpose的简单使用
01-08
可以直接使用的openpose代码，操作简单，已经将模型下载好并放进工程了，可以直接运行。
OpenPose 对于原始的mobilenet v1的预训练模型是 如何使用的
flyfish
03-03 1504
OpenPose 对于原始的mobilenet v1的预训练模型是 如何使用的 flyfish 关于问题 这里涉及到两部分 例如 OpenPose的backbone 可以是 vgg，mobilenet 也可以是其他的经典模型 假设 官方提供的标准网络架构例如 mobilenet v1 经过改造的mobilenet网络架构 叫 dilated mobilenetv1 问题出现了 mobilenetv...
caffe-openpose结构
xidaoliang的博客
05-13 2654
一、openpose自己的网络层 1、数据层 layer { name: "data" 表示该层名字 type: "CPMData" 层有多种类型，比如：Data、Convolution、Pooling，Data表示数据来源于Leveldb或者LMDB top: "data" ...
人体姿态估计算法之open pose
maopig的专栏
03-16 4267
一，openpose是一种自底向上的算法： OpenPose人体姿态识别项目是美国卡耐基梅隆大学（CMU）基于卷积神经网络和监督学习并以Caffe为框架开发的开源库。可以实现人体动作、面部表情、手指运动等姿态估计。适用于单人和多人，具有极好的鲁棒性。是世界上首个基于深度学习的实时多人二维姿态估计应用，基于它的实例如雨后春笋般涌现。 检测所有的关键点，再group成不同的人，是当前比较流行的人体姿态评估算法之一。OpenPose 大获成功的一部分原因是它在 GitHub 上...
openpose姿态估计详解【学习笔记】
qq_23022733的博客
08-15 5037
整体框架如下，1张图片经过CNN网络后分成2个网络，Parts Detection网络是预测关键点，Parts Association网络是预测方向，人体18个关键点总共需要19个不同的方向，而确定方向至少需要1个平面，即。stage越多相当于层数越深，模型感受野越大，姿态估计需要更大的感受野，因为进行关键点检测需要更多关于人体的信息，所以感受野越大则人体的信息越多，关键点检测越能检测准确。在本项目中，需要检测人体18个关键点，除了下图所标注的17个关键点外，还有1个脖子关键点。2、姿势的‘亲和力’向量。
yolov8 mobilenet更换backbone
01-13
YOLOv8是一种目标检测算法，它使用了MobileNetV3作为其Backbone主干网络。通过将MobileNetV3与YOLOv8结合，可以提高目标检测的性能和效果。 要更换YOLOv8的Backbone为MobileNetV3，可以按照以下步骤进行操作： 1. ...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

西笑生

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值