SiamBAN 前向推理的大致记录

于 2022-06-02 15:29:42 发布
阅读量518 收藏 3
点赞数
文章标签： 计算机视觉 深度学习 神经网络
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/allrubots/article/details/125088788
版权

目录

 1. backbone结构

2. neck结构 

3. head结构

4. 模板输入 z 的变化

（1） 原始输入 z

 （2）经过backbone后的特征

 （3）经过neck后的特征

5. 搜索区域x的变化

（1）原始输入x

  （2）经过backbone后的特征

（3）经过neck后的特征

6. head操作

（1）cls分支输出过程变化

 （2）loc分支输出过程变化

（3）最终的输出

 1. backbone结构

包含空洞卷积的，搭建的过程在siamban\models\backbone\resnet_atrous.py，残差相加体现在该文件中基本模块类的定义中的前向传播过程中

ResNet(
  (conv1): Conv2d(3, 64, kernel_size=(7, 7), stride=(2, 2), bias=False)
  (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
  (relu): ReLU(inplace=True)
  (maxpool): MaxPool2d(kernel_size=3, stride=2, padding=1, dilation=1, ceil_mode=False)
  (layer1): Sequential(
    (0): Bottleneck(
      (conv1): Conv2d(64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (conv3): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (bn3): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (relu): ReLU(inplace=True)
      (downsample): Sequential(
        (0): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      )
    )
    (1): Bottleneck(
      (conv1): Conv2d(256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (conv3): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (bn3): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (relu): ReLU(inplace=True)
    )
    (2): Bottleneck(
      (conv1): Conv2d(256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (conv3): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (bn3): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (relu): ReLU(inplace=True)
    )
  )
  (layer2): Sequential(
    (0): Bottleneck(
      (conv1): Conv2d(256, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(2, 2), bias=False)
      (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (conv3): Conv2d(128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (bn3): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (relu): ReLU(inplace=True)
      (downsample): Sequential(
        (0): Conv2d(256, 512, kernel_size=(3, 3), stride=(2, 2), bias=False)
        (1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      )
    )
    (1): Bottleneck(
      (conv1): Conv2d(512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (conv3): Conv2d(128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (bn3): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (relu): ReLU(inplace=True)
    )
    (2): Bottleneck(
      (conv1): Conv2d(512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (conv3): Conv2d(128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (bn3): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (relu): ReLU(inplace=True)
    )
    (3): Bottleneck(
      (conv1): Conv2d(512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (conv3): Conv2d(128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (bn3): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (relu): ReLU(inplace=True)
    )
  )
  (layer3): Sequential(
    (0): Bottleneck(
      (conv1): Conv2d(512, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (relu): ReLU(inplace=True)
      (downsample): Sequential(
        (0): Conv2d(512, 1024, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (1): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      )
    )
    (1): Bottleneck(
      (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False)
      (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (relu): ReLU(inplace=True)
    )
    (2): Bottleneck(
      (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False)
      (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (relu): ReLU(inplace=True)
    )
    (3): Bottleneck(
      (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False)
      (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (relu): ReLU(inplace=True)
    )
    (4): Bottleneck(
      (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False)
      (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (relu): ReLU(inplace=True)
    )
    (5): Bottleneck(
      (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False)
      (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (relu): ReLU(inplace=True)
    )
  )
  (layer4): Sequential(
    (0): Bottleneck(
      (conv1): Conv2d(1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False)
      (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (conv3): Conv2d(512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (bn3): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (relu): ReLU(inplace=True)
      (downsample): Sequential(
        (0): Conv2d(1024, 2048, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False)
        (1): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      )
    )
    (1): Bottleneck(
      (conv1): Conv2d(2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(4, 4), dilation=(4, 4), bias=False)
      (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (conv3): Conv2d(512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (bn3): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (relu): ReLU(inplace=True)
    )
    (2): Bottleneck(
      (conv1): Conv2d(2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(4, 4), dilation=(4, 4), bias=False)
      (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (conv3): Conv2d(512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (bn3): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (relu): ReLU(inplace=True)
    )
  )
)

2. neck结构 

AdjustAllLayer(
  (downsample2): AdjustLayer(
    (downsample): Sequential(
      (0): Conv2d(512, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    )
  )
  (downsample3): AdjustLayer(
    (downsample): Sequential(
      (0): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    )
  )
  (downsample4): AdjustLayer(
    (downsample): Sequential(
      (0): Conv2d(2048, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    )
  )
)

3. head结构

MultiBAN(
  (box2): DepthwiseBAN(
    (cls): DepthwiseXCorr(
      (conv_kernel): Sequential(
        (0): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), bias=False)
        (1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (2): ReLU(inplace=True)
      )
      (conv_search): Sequential(
        (0): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), bias=False)
        (1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (2): ReLU(inplace=True)
      )
      (head): Sequential(
        (0): Conv2d(256, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (2): ReLU(inplace=True)
        (3): Conv2d(256, 2, kernel_size=(1, 1), stride=(1, 1))
      )
    )
    (loc): DepthwiseXCorr(
      (conv_kernel): Sequential(
        (0): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), bias=False)
        (1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (2): ReLU(inplace=True)
      )
      (conv_search): Sequential(
        (0): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), bias=False)
        (1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (2): ReLU(inplace=True)
      )
      (head): Sequential(
        (0): Conv2d(256, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (2): ReLU(inplace=True)
        (3): Conv2d(256, 4, kernel_size=(1, 1), stride=(1, 1))
      )
    )
  )
  (box3): DepthwiseBAN(
    (cls): DepthwiseXCorr(
      (conv_kernel): Sequential(
        (0): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), bias=False)
        (1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (2): ReLU(inplace=True)
      )
      (conv_search): Sequential(
        (0): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), bias=False)
        (1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (2): ReLU(inplace=True)
      )
      (head): Sequential(
        (0): Conv2d(256, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (2): ReLU(inplace=True)
        (3): Conv2d(256, 2, kernel_size=(1, 1), stride=(1, 1))
      )
    )
    (loc): DepthwiseXCorr(
      (conv_kernel): Sequential(
        (0): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), bias=False)
        (1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (2): ReLU(inplace=True)
      )
      (conv_search): Sequential(
        (0): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), bias=False)
        (1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (2): ReLU(inplace=True)
      )
      (head): Sequential(
        (0): Conv2d(256, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (2): ReLU(inplace=True)
        (3): Conv2d(256, 4, kernel_size=(1, 1), stride=(1, 1))
      )
    )
  )
  (box4): DepthwiseBAN(
    (cls): DepthwiseXCorr(
      (conv_kernel): Sequential(
        (0): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), bias=False)
        (1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (2): ReLU(inplace=True)
      )
      (conv_search): Sequential(
        (0): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), bias=False)
        (1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (2): ReLU(inplace=True)
      )
      (head): Sequential(
        (0): Conv2d(256, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (2): ReLU(inplace=True)
        (3): Conv2d(256, 2, kernel_size=(1, 1), stride=(1, 1))
      )
    )
    (loc): DepthwiseXCorr(
      (conv_kernel): Sequential(
        (0): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), bias=False)
        (1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (2): ReLU(inplace=True)
      )
      (conv_search): Sequential(
        (0): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), bias=False)
        (1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (2): ReLU(inplace=True)
      )
      (head): Sequential(
        (0): Conv2d(256, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (2): ReLU(inplace=True)
        (3): Conv2d(256, 4, kernel_size=(1, 1), stride=(1, 1))
      )
    )
  )
)

4. 模板输入 z 的变化

（1） 原始输入 z

（1，3，127，127）

 （2）经过backbone后的特征

# {list:3} [Tensor:(1,512,15,15),Tensor:(1,1024,15,15),Tensor:(1,2048,15,15)]

变化过程

 （3）经过neck后的特征

# {list:3} [Tensor:(1,256,7,7),Tensor:(1,256,7,7),Tensor:(1,256,7,7)]

有个这样的操作

    def forward(self, x):
        x = self.downsample(x)
        if x.size(3) < 16:  # ...
            l = 4
            r = l + 7
            x = x[:, :, l:r, l:r]
        return x

5. 搜索区域x的变化

（1）原始输入x

（1，3，255，255）

  （2）经过backbone后的特征

# {list:3} [Tensor:(1,512,31,31),Tensor:(1,1024,31,31),Tensor:(1,2048,31,31)]

（3）经过neck后的特征

# {list:3} [Tensor:(1,256,31,31),Tensor:(1,256,31,31),Tensor:(1,256,31,31)]

6. head操作

首先，这几个head不共享网络参数，见3 head 网络结构

（1）cls分支输出过程变化

 （2）loc分支输出过程变化

回归分支最后取了exp，

loc.append(torch.exp(l*self.loc_scale[idx-2]))
class MultiBAN(BAN):
    def __init__(self, in_channels, cls_out_channels, weighted=False):
        super(MultiBAN, self).__init__()
        self.weighted = weighted  # True
        for i in range(len(in_channels)):
            self.add_module('box'+str(i+2), DepthwiseBAN(in_channels[i], in_channels[i], cls_out_channels))
        if self.weighted:
            self.cls_weight = nn.Parameter(torch.ones(len(in_channels)))
            self.loc_weight = nn.Parameter(torch.ones(len(in_channels)))
        self.loc_scale = nn.Parameter(torch.ones(len(in_channels)))
        
if self.weighted:
      cls_weight = F.softmax(self.cls_weight, 0)
      loc_weight = F.softmax(self.loc_weight, 0)

其中nn.Parameter中的参数也可以进行优化，参考PyTorch中的torch.nn.Parameter() 详解

        def weighted_avg(lst, weight):  # 每个输出乘以权重再加和，这个权重已经softmax过了，所以加和后并没有进行平均操作。
            s = 0
            for i in range(len(weight)):
                s += lst[i] * weight[i]
            return s

        if self.weighted:
            return weighted_avg(cls, cls_weight), weighted_avg(loc, loc_weight)  # 返回乘以权重然后再加和的输出

 每个head的输出 乘以 权值 然后 加和

（3）最终的输出

 cls ---- (1,2,25,25)    loc-----(1,4,25,25)

匿名的魔术师
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 6
    评论
TensorRT 深度学习前向推理简单介绍
jsa158的博客
12-30 1万+
二、TensorRT介绍 TensorRT 现在是inference 精度最高，速度最快的，而且在不断的改进过程中，在保证软件精度的同时，不断提高速度；TensorRT只能用来做Inference，不能用来做train； TensorRT V1不能和caffe 同时工作，Release-V2解决这个问题，内部测试已经没有问题。 1、TensorRT的需要的文件 需要
前向推理--darknet和ncnn
seiyaaa的专栏
03-31 1327
背景 最近在训练yolo，得到的best模型结构，输出是两个yolo，那推理时候是使用哪个output呢？ yolov3原版是3个yolo节点的 yolo的predict代码逻辑 执行的命令如下： darknet.exe detector test cfg/coco.data yolov4.cfg yolov4.weights -ext_output dog.jpg 结合darknet.c源码可以看出在预测时候，从最后往前找layer type，第一个不是COST类型，就break跳出循环，取出
SiamBAN
qq_38680752的博客
11-13 4325
3. SiamBAN 框架         在本节中，我们将描述建议的SiamBAN框架。如图2所示，SiamBAN由一个Siamese网络主干网和多个box自适应磁头组成。Siamese网络主干负责计算模板块和搜索块的卷积特征映射，它使用了现成的卷积网络。box自适应头包括分类模块和回归模块。具体来说，分类模块对相关层的每个点进行前-背景分类，回归模块对对应位置进行包围盒预测。 图2：提出的box自适应网络的架构。左图为其主
基于规则的前向链接推理JAVA实现
11-08
基于规则的前向链接推理技术的java实现，简单易懂，适合初学者。
如何阅读一个前向推理框架？以NCNN为例。
I good vegetable a!
12-20 2314
【GiantPandaCV导语】自NCNN开源以来，其它厂商的端侧推理框架或者搭载特定硬件芯片的工具链层出不穷。如何去繁从简的阅读一个深度学习推理框架十分重要，这篇文章记录了我是如何阅读NCNN框架的，希望对一些不知道如何下手的读者有一点启发。 0x00. 想法来源 CNN从15年的ResNet在ImageNet比赛中大放异彩，到今天各种层出不穷的网络结构被提出以解决生活中碰到的各种问题。然而，在CNN长期发展过程中，也伴随着很多的挑战，比如如何调整算法使得在特定场景或者说数据集上取得最好的精度，如何将.
yolov5 通过NCNN实现前向推理的文件
02-24
3. **测试与验证**：转换完成后，为了确保模型在NCNN中的正确性，需要进行前向推理测试。这通常涉及到加载.param和.bin文件到NCNN环境中，运行一个或多个测试图像，然后对比原PyTorch模型和NCNN模型的检测结果，确认...
基于Caffe加速卷积神经网络前向推理.pdf
09-26
【基于Caffe加速卷积神经网络前向推理】 在深度学习领域，卷积神经网络（CNN）是核心组件之一，广泛应用于图像识别、自然语言处理等任务。然而，随着网络结构的复杂化，前向推理过程中的计算量和内存访问效率成为...
模糊推理过程大致如下.pdf
最新发布
06-17
模糊推理过程大致如下.pdf
洗衣机模糊推理系统实验.rar
11-14
在这个实验中，文件"洗衣机模糊推理.docx"很可能是实验报告，详细记录了实验设计、实现过程以及结果分析。可能包含以下内容： - 实验目的：理解模糊推理系统的工作原理，掌握模糊逻辑在实际问题中的应用。 - 实验...
siamban:用于视觉跟踪的连体盒自适应网络
04-14
暹罗银行 该项目托管用于实现SiamBAN算法以进行视觉跟踪的代码，如我们的论文所述： @inproceedings{siamban, title={Siamese Box Adaptive Network for Visual Tracking}, author={Chen, Zedu and Zhong, Bineng and Li, Guorong and Zhang, Shengping and Ji, Rongrong}, booktitle={Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition}, pages={6668--6677}, year={2020} } 全文可。 原始结果在或，提取代码： um9k 。 基于的代码。 SiamBAN
SiamBAN详细分析，一看就懂！
cxkyxx的博客
10-04 1万+
整体把握 SiamBAN是今年CVPR中效果最好的跟踪器之一，研究它的原理更加能够很好的帮助我们掌握目前跟踪器发展的趋势。 SIamBAN，按照意思分析是孪生自适应框。“孪生”，说明该跟踪使用了Siamese网络架构；而“自适应框”，则是该跟踪器采用了anchor-free的策略，不预先设定anchor框的尺寸，使得框拥有更大强大的自由度。 通过分析论文和代码，我认为SiamBAN就是一个优化版的SiamRPN++，最大的创新点在于anchor-free的引用，去掉了预定义的anchor，从而使得模型整体的
CVPR-2020-SiamBAN:Siamese Box Adaptive Network for Visual Tracking阅读笔记
菜菜子hoho的博客
05-19 1227
论文地址：https://arxiv.org/pdf/2003.06761.pdf 论文代码：https://github.com/hqucv/siamban 一、 动机： 现有的追踪器大多依赖于多尺度测试和预定义的锚框来对目标进行精确地位，但这样就需要先验知识和一系列设计候选盒子的超参数，所以为了解决这个问题设计了更加灵活通用的SiamBAN。该算法将视觉跟踪问题视为一个并行分类和回归问题，直接对目标进行分类，并在统一的FCN中回归其边界框。并且，神经科学家已经表明，生物视觉初级视觉皮层可以快速有效地从复
训练SiamBAN报错问题
qwerasdzz的博客
05-07 1483
我是用windows平台来训练siamBAN,在商汤科技的开源项目pysot上使用python3.7来进行，pysot代码地址 https://github.com/STVIR/pysot 第一个问题 KeyError:‘RANK’ 定位到错误语句 使用os.environ.keys() 命令查看主目录下所有的 key，经过排查，是因为os.environ当中没有RANK这个key。 解决方法 os.environ['RANK']='0' 这块代码是用来设置GPU单卡/多卡训练的。 问题二 pyto
CVPR 2020目标跟踪多篇开源论文（上）
吴建明wujianming_110117
05-11 989
CVPR 2020目标跟踪多篇开源论文（上） SiamBAN：面向目标跟踪的Siamese Box自适应网络 作者团队：华侨大学&中科院&哈工大&鹏城实验室&厦门大学等 论文链接：https://arxiv.org/abs/2003.06761 代码链接：https://github.com/hqucv/siamban 注：表现SOTA！速度高达40 FPS！性能优于DiMP、SiamRPN++和ATOM等网络。 大多数现有的跟踪器通常依赖于多尺度搜索方案或预定义的anc
感知机和多层感知机详细学习
frighting_ing的博客
04-07 3853
1. 感知机的前向推理？ 感知机其实就是类似神经网络的一个神经元 w0相当于bias，也就是偏置 w1-wn是权重 step fuction是sign 前向推理的公式 2. 感知机的loss function是什么？ loss function即目标函数，模型所要去干的事情就是我们所定义的目标函数 这里采用各个误分类点与超平面的距离来定义。 图中（目前以输入为2维（x为x1和x2）情况下举例）w为超平面的法向量，与法向量夹角为锐角即为+1的分类，与法向量夹角为钝角为-1的分类 具体公式： 其.
SiamRPN++算法详解
WZZ18191171661的博客
03-15 3万+
论文题目：SiamRPN++: Evolution of Siamese Visual Tracking with Very Deep Networks 论文链接：论文链接 论文代码：后续会开源 一、SiamRPN和DaSiamRPN回顾 1、SiamRPN 基于SiamFC, 引入了Faster RCNN中的RPN模块，让tracker可以回归位置、形状，可以省掉多尺度测试，提高算法性能的同时...
Samba详解
weixin_34319640的博客
11-14 307
一、Samba简介 二、安装 三、smb.conf详解 四、实验 五、其他一、Samba简介实现Windows和Linux之间互相共享资源 SMB:service message block:服务信息块,SMB协议在局域网上用于服务器文件访问和打印的协议 cifs:common internet filesystem//CIFS是开放的SMB协议...
卷积特征图可视化
m0_47411878的博客
10-18 3709
卷积特征图可视化代码解析（含有注释）目录格式初始化加载模型输出卷积层信息可视化卷积核可视化图像生成每个卷积层的特征图特征图可视化部分特征图图片 参考 https://debuggercafe.com/visualizing-filters-and-feature-maps-in-convolutional-neural-networks-using-pytorch/ 代码解析（含有注释） 目录格式 图片来自https://pixabay.com/zh/photos/cat-red-cat-cat-s-
PyTorch学习之归一化层（BatchNorm、LayerNorm、InstanceNorm、GroupNorm）
热门推荐
mingo_敏
12-18 11万+
BN，LN，IN，GN从学术化上解释差异： BatchNorm：batch方向做归一化，算NHW的均值 LayerNorm：channel方向做归一化，算CHW的均值 InstanceNorm：一个channel内做归一化，算H*W的均值 GroupNorm：将channel方向分group，然后每个group内做归一化，算(C//G)HW的均值 ...
如何对前向推理神经网络进行训练
06-01
前向推理神经网络的训练通常采用监督学习的方式，即给定输入特征和对应的标签，通过最小化损失函数来优化网络权重，使得网络的预测结果与标签尽可能接近。具体来说，训练前向推理神经网络需要以下步骤： 1. 定义网络结构：选择网络结构，包括输入层、隐藏层和输出层的神经元数量和激活函数等。 2. 准备数据集：将数据集分为训练集、验证集和测试集，其中训练集用于训练网络，验证集用于调整网络参数，测试集用于评估网络性能。 3. 初始化网络参数：随机初始化网络的权重和偏置。 4. 前向传播：使用当前网络参数计算输入数据的预测结果。 5. 计算损失函数：将预测结果与真实标签进行比较，计算损失函数。 6. 反向传播：基于损失函数计算梯度，并使用反向传播算法更新网络参数。 7. 重复步骤4至6，直到损失函数收敛或达到最大迭代次数。 8. 模型评估：使用测试集评估模型的性能，包括准确率、精度、召回率等指标。 9. 调整模型：根据测试结果调整模型结构、超参数等。 10. 部署模型：将训练好的模型部署到实际应用中使用。
评论 6
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

匿名的魔术师

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

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

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

打赏作者

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

抵扣说明：

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

余额充值