Siamese目标跟踪系列学习笔记

最新推荐文章于 2023-01-05 17:42:49 发布
最新推荐文章于 2023-01-05 17:42:49 发布
阅读量330 收藏 1
点赞数
分类专栏： pytorch
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/My_Communication/article/details/118000613
版权

1. 网络结构

消除padding对跟踪过程的影响

def center_crop(x):
    """
    center crop layer. crop [1:-2] to eliminate padding influence.
    Crop 1 element around the tensor
    input x can be a Variable or Tensor
    """
    return x[:, :, 1:-1, 1:-1].contiguous()

带有padding的3X3卷积

def conv3x3(in_planes, out_planes, stride=1):
    """3x3 convolution with padding"""
    return nn.Conv2d(in_planes, out_planes, kernel_size=3, stride=stride,
                     padding=1, bias=False)

resnet网络输出裁剪

def center_crop7(x):
    """
    Center crop layer for stage1 of resnet. (7*7)
    input x can be a Variable or Tensor
    """

    return x[:, :, 2:-2, 2:-2].contiguous()

1X1卷积

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

BottleNet

# -------------------------------
# Several Kinds Bottleneck Blocks
# -------------------------------
class Bottleneck_CI(nn.Module):
    """
    Bottleneck with center crop layer, utilized in CVPR2019 model
    """
    expansion = 4

    def __init__(self, inplanes, planes, last_relu, stride=1, downsample=None, dilation=1):
        super(Bottleneck_CI, self).__init__()
        self.conv1 = nn.Conv2d(inplanes, planes, kernel_size=1, bias=False)
        self.bn1 = nn.BatchNorm2d(planes)

        padding = 1
        if abs(dilation - 2) < eps: padding = 2
        if abs(dilation - 3) < eps: padding = 3

        self.conv2 = nn.Conv2d(planes, planes, kernel_size=3, stride=stride, padding=padding, bias=False, dilation=dilation)
        self.bn2 = nn.BatchNorm2d(planes)
        self.conv3 = nn.Conv2d(planes, planes * self.expansion, kernel_size=1, bias=False)
        self.bn3 = nn.BatchNorm2d(planes * self.expansion)
        self.relu = nn.ReLU(inplace=True)
        self.downsample = downsample
        self.stride = stride
        self.last_relu = last_relu

    def forward(self, x):
        residual = 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:
            residual = self.downsample(x)

        out += residual

        if self.last_relu:         # remove relu for the last block
            out = self.relu(out)

        out = center_crop(out)     # in-residual crop

        return out


class Bottleneck_BIG_CI(nn.Module):
    """
    Bottleneck with center crop layer, double channels in 3*3 conv layer in shortcut branch
    """
    expansion = 4

    def __init__(self, inplanes, planes, last_relu, stride=1, downsample=None, dilation=1):
        super(Bottleneck_BIG_CI, self).__init__()
        self.conv1 = nn.Conv2d(inplanes, planes, kernel_size=1, bias=False)
        self.bn1 = nn.BatchNorm2d(planes)

        padding = 1
        if abs(dilation - 2) < eps: padding = 2
        if abs(dilation - 3) < eps: padding = 3

        self.conv2 = nn.Conv2d(planes, planes*2, kernel_size=3, stride=stride, padding=padding, bias=False, dilation=dilation)
        self.bn2 = nn.BatchNorm2d(planes*2)
        self.conv3 = nn.Conv2d(planes*2, planes * self.expansion, kernel_size=1, bias=False)
        self.bn3 = nn.BatchNorm2d(planes * self.expansion)
        self.relu = nn.ReLU(inplace=True)
        self.downsample = downsample
        self.stride = stride
        self.last_relu = last_relu

    def forward(self, x):
        residual = 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:
            residual = self.downsample(x)

        out += residual

        if self.last_relu:  # feature out no relu
            out = self.relu(out)

        out = center_crop(out)  # in-layer crop

        return out

对padding有裁剪的bottle

class Bottleneck_BIG_CI(nn.Module):
    """
    Bottleneck with center crop layer, double channels in 3*3 conv layer in shortcut branch
    """
    expansion = 4

    def __init__(self, inplanes, planes, last_relu, stride=1, downsample=None, dilation=1):
        super(Bottleneck_BIG_CI, self).__init__()
        self.conv1 = nn.Conv2d(inplanes, planes, kernel_size=1, bias=False)
        self.bn1 = nn.BatchNorm2d(planes)

        padding = 1
        if abs(dilation - 2) < eps: padding = 2
        if abs(dilation - 3) < eps: padding = 3

        self.conv2 = nn.Conv2d(planes, planes*2, kernel_size=3, stride=stride, padding=padding, bias=False, dilation=dilation)
        self.bn2 = nn.BatchNorm2d(planes*2)
        self.conv3 = nn.Conv2d(planes*2, planes * self.expansion, kernel_size=1, bias=False)
        self.bn3 = nn.BatchNorm2d(planes * self.expansion)
        self.relu = nn.ReLU(inplace=True)
        self.downsample = downsample
        self.stride = stride
        self.last_relu = last_relu

    def forward(self, x):
        residual = 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:
            residual = self.downsample(x)

        out += residual

        if self.last_relu:  # feature out no relu
            out = self.relu(out)

        out = center_crop(out)  # in-layer crop

        return out

其他

# ---------------------
# ResNeXt Tools
# ---------------------

class ResNet(nn.Module):
    """
    ResNet with 22 layer utilized in CVPR2019 paper.
    Usage: ResNet(Bottleneck_CI, [3, 4], [True, False], [False, True], 64, [64, 128])
    """

    def __init__(self, block, layers, last_relus, s2p_flags, firstchannels=64, channels=[64, 128], dilation=1):
        self.inplanes = firstchannels
        self.stage_len = len(layers)
        super(ResNet, self).__init__()
        self.conv1 = nn.Conv2d(3, firstchannels, kernel_size=7, stride=2, padding=3, bias=False)
        self.bn1 = nn.BatchNorm2d(firstchannels)
        self.relu = nn.ReLU(inplace=True)
        self.maxpool = nn.MaxPool2d(kernel_size=2, stride=2)

        # stage2
        if s2p_flags[0]:
            self.layer1 = self._make_layer(block, channels[0], layers[0], stride2pool=True, last_relu=last_relus[0])
        else:
            self.layer1 = self._make_layer(block, channels[0], layers[0], last_relu=last_relus[0])

        # stage3
        if s2p_flags[1]:
            self.layer2 = self._make_layer(block, channels[1], layers[1], stride2pool=True, last_relu=last_relus[1], dilation=dilation)
        else:
            self.layer2 = self._make_layer(block, channels[1], layers[1], last_relu=last_relus[1], dilation=dilation)

        for m in self.modules():
            if isinstance(m, nn.Conv2d):
                nn.init.kaiming_normal(m.weight, mode='fan_out')
            elif isinstance(m, nn.BatchNorm2d):
                nn.init.constant(m.weight, 1)
                nn.init.constant(m.bias, 0)

    def _make_layer(self, block, planes, blocks, last_relu, stride=1, stride2pool=False, dilation=1):
        """
        :param block:
        :param planes:
        :param blocks:
        :param stride:
        :param stride2pool: translate (3,2) conv to (3, 1)conv + (2, 2)pool
        :return:
        """
        downsample = None
        if stride != 1 or self.inplanes != planes * block.expansion:
            downsample = nn.Sequential(
                nn.Conv2d(self.inplanes, planes * block.expansion,
                          kernel_size=1, stride=stride, bias=False),
                nn.BatchNorm2d(planes * block.expansion),
            )

        layers = []
        layers.append(block(self.inplanes, planes, last_relu=True, stride=stride, downsample=downsample, dilation=dilation))
        if stride2pool:
            layers.append(self.maxpool)
        self.inplanes = planes * block.expansion
        for i in range(1, blocks):
            if i == blocks - 1:
                layers.append(block(self.inplanes, planes, last_relu=last_relu, dilation=dilation))
            else:
                layers.append(block(self.inplanes, planes, last_relu=True, dilation=dilation))

        return nn.Sequential(*layers)

    def forward(self, x):
        x = self.conv1(x)     # stride = 2
        x = self.bn1(x)
        x = self.relu(x)
        x = center_crop7(x)
        x = self.maxpool(x)   # stride = 4

        x = self.layer1(x)
        x = self.layer2(x)    # stride = 8

        return x


# --------------------------
# Inception Tools (320, 640)
# --------------------------
class BasicConv2d_1x1(nn.Module):
    """
    1*1 branch of inception
    """

    def __init__(self, in_channels, out_channels, last_relu=True, **kwargs):
        super(BasicConv2d_1x1, self).__init__()
        self.conv = nn.Conv2d(in_channels, out_channels, bias=False, **kwargs)
        self.bn = nn.BatchNorm2d(out_channels, eps=0.001)
        self.last_relu = last_relu

    def forward(self, x):
        x = self.conv(x)
        x = self.bn(x)

        if self.last_relu:
            return F.relu(x, inplace=True)
        else:
            return x


class BasicConv2d_3x3(nn.Module):
    """
    3*3 branch of inception
    """
    expansion = 4

    def __init__(self, inplanes, planes, last_relu=True):
        super(BasicConv2d_3x3, self).__init__()
        self.conv1 = nn.Conv2d(inplanes, planes, kernel_size=1, bias=False)
        self.bn1 = nn.BatchNorm2d(planes)
        self.conv2 = nn.Conv2d(planes, planes, kernel_size=3, stride=1, padding=1, bias=False)
        self.bn2 = nn.BatchNorm2d(planes)
        self.conv3 = nn.Conv2d(planes, planes * self.expansion, kernel_size=1, bias=False)
        self.bn3 = nn.BatchNorm2d(planes * self.expansion)
        self.relu = nn.ReLU(inplace=True)
        self.last_relu = last_relu

    def forward(self, 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.last_relu:
            out = self.relu(out)

        return out


class InceptionM(nn.Module):
    """
    Inception module with 1*1 and 3*3 branch
    """

    def __init__(self, in_channels, planes, last_relu=True):
        super(InceptionM, self).__init__()
        self.branch3x3 = BasicConv2d_3x3(in_channels, planes, last_relu)
        self.branch1x1 = BasicConv2d_1x1(in_channels, planes, last_relu, kernel_size=1)

    def forward(self, x):
        branch3x3 = self.branch3x3(x)
        branch1x1 = self.branch1x1(x)

        outputs = [branch3x3, branch1x1]
        return center_crop(torch.cat(outputs, 1))   # in-layer crop


class Inception(nn.Module):
    """
    Inception with 22 layer utilized in CVPR2019 paper.
    Usage: Inception(InceptionM, [3, 4], [True, False])
    """

    def __init__(self, block, layers):
        self.inplanes = 64
        super(Inception, self).__init__()
        self.conv1 = nn.Conv2d(3, 64, kernel_size=7, stride=2, padding=0, bias=False)
        self.bn1 = nn.BatchNorm2d(64)
        self.relu = nn.ReLU(inplace=True)
        self.maxpool1 = nn.MaxPool2d(kernel_size=3, stride=2)
        self.maxpool = nn.MaxPool2d(kernel_size=2, stride=2)
        self.layer1 = self._make_layer(block, 64, 64, layers[0], pool=False)     # in=64, out=320
        self.layer2 = self._make_layer(block, 320, 128, layers[1], pool=True, last_relu=False)   # in=320, out=640

        for m in self.modules():
            if isinstance(m, nn.Conv2d):
                nn.init.kaiming_normal(m.weight, mode='fan_out')
            elif isinstance(m, nn.BatchNorm2d):
                nn.init.constant(m.weight, 1)
                nn.init.constant(m.bias, 0)

    def _make_layer(self, block, inchannels, planes, blocks, pool=True, last_relu=True):

        layers = []
        for i in range(0, blocks):
            if i == 0:
                self.inchannels = inchannels
            else:
                self.inchannels = planes * 5

            if i == 1 and pool:
                layers.append(self.maxpool)

            if i == blocks - 1 and not last_relu:
                layers.append(block(self.inchannels, planes, last_relu))
            else:
                layers.append(block(self.inchannels, planes))

        return nn.Sequential(*layers)

    def forward(self, x):
        x = self.conv1(x)
        x = self.bn1(x)
        x = self.relu(x)
        x = self.maxpool1(x)
        x = self.layer1(x)
        x = self.layer2(x)

        return x


# --------------
# ResNeXt Tools
# --------------
class BasicBlock_C(nn.Module):
    """
    increasing cardinality is a more effective way of
    gaining accuracy than going deeper or wider
    """

    def __init__(self, in_planes, bottleneck_width=4, cardinality=32, expansion=2, last_relu=True):
        super(BasicBlock_C, self).__init__()
        inner_width = cardinality * bottleneck_width
        self.expansion = expansion
        self.basic = nn.Sequential(OrderedDict(
            [
                ('conv1_0', nn.Conv2d(in_planes, inner_width, 1, stride=1, bias=False)),
                ('bn1', nn.BatchNorm2d(inner_width)),
                ('act0', nn.ReLU()),
                ('conv3_0',
                 nn.Conv2d(inner_width, inner_width, 3, stride=1, padding=1, groups=cardinality, bias=False)),
                ('bn2', nn.BatchNorm2d(inner_width)),
                ('act1', nn.ReLU()),
                ('conv1_1', nn.Conv2d(inner_width, inner_width * self.expansion, 1, stride=1, bias=False)),
                ('bn3', nn.BatchNorm2d(inner_width * self.expansion))
            ]
        ))
        self.shortcut = nn.Sequential()
        if in_planes != inner_width * self.expansion:
            self.shortcut = nn.Sequential(
                nn.Conv2d(in_planes, inner_width * self.expansion, 1, stride=1, bias=False)
            )
        self.bn0 = nn.BatchNorm2d(self.expansion * inner_width)
        self.last_relu = last_relu

    def forward(self, x):
        out = self.basic(x)
        out += self.shortcut(x)

        if self.last_relu:
            return center_crop(F.relu(self.bn0(out)))    # CIR
        else:
            return center_crop(self.bn0(out))


class ResNeXt(nn.Module):
    """
    ResNeXt with 22 layer utilized in CVPR2019 paper.
    Usage: ResNeXt([3, 4], 32, 4)
    """
    def __init__(self, num_blocks, cardinality, bottleneck_width, expansion=2):
        super(ResNeXt, self).__init__()
        self.cardinality = cardinality
        self.bottleneck_width = bottleneck_width
        self.in_planes = 64
        self.expansion = expansion
        self.maxpool1 = nn.MaxPool2d(kernel_size=3, stride=2)
        self.maxpool = nn.MaxPool2d(kernel_size=2, stride=2)

        self.conv0 = nn.Conv2d(3, self.in_planes, kernel_size=7, stride=2, padding=0)
        self.bn0 = nn.BatchNorm2d(self.in_planes)
        self.layer1 = self._make_layer(num_blocks[0],  last_relu=True)
        self.layer2 = self._make_layer(num_blocks[1],  last_relu=False, stride2pool=True)

        for m in self.modules():
            if isinstance(m, nn.Conv2d):
                nn.init.kaiming_normal(m.weight, mode='fan_out')
            elif isinstance(m, nn.BatchNorm2d):
                nn.init.constant(m.weight, 1)
                nn.init.constant(m.bias, 0)

    def _make_layer(self, num_blocks, last_relu=True, stride2pool=False):

        layers = []
        for i in range(0, num_blocks):
            if i == num_blocks - 1:
                layers.append(BasicBlock_C(self.in_planes, self.bottleneck_width, self.cardinality, self.expansion, last_relu=last_relu))
            else:
                layers.append(BasicBlock_C(self.in_planes, self.bottleneck_width, self.cardinality, self.expansion))
            self.in_planes = self.expansion * self.bottleneck_width * self.cardinality

            if i == 0 and stride2pool:
                layers.append(self.maxpool)

        self.bottleneck_width *= 2

        return nn.Sequential(*layers)

    def forward(self, x):
        out = F.relu(self.bn0(self.conv0(x)))
        out = self.maxpool1(out)

        out = self.layer1(out)
        out = self.layer2(out)

        return out
大别山伧父
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
目标追踪（一）：siamese-fc
qq_28778507的博客
04-15 1932
这是2016CVPR收录的 在此之前，目标追踪一般都是online的，在这里引入了深度学习offline的训练，他提出了一种思想：similarity learning 他有三大contribution： 首先在速度上可以实现实时检测 通过一个范本来定位想要的被追踪物体（detection物体为卷积核，卷积下一帧的feature map） 使用了全卷积网络 他的 缺点： 如果物体size变化...
【目标跟踪】SiameseFC & CFNet
kobe_huai的博客
12-02 1万+
SiameseFC：Fully-Convolutional Siamese Networks for Object Tracking CFNet:End-to-end representation learning for Correlation Filter based trac
目标跟踪+siamese 网络+论文与对应代码实现
最新发布
05-11
目标跟踪+siamese 网络+论文与对应代码实现 目标跟踪算法相关代码与论文实现，对于目标跟踪初学者很好的入门项目
异常检测 | 基于Siamese网络学习距离函数来定位视频中的异常
LiRongLu_的博客
04-18 3633
关于Learning a distance function with a Siamese network to localize anomalies in videos论文学习 作者通过训练一个 Siamese 神经网络，将手工制作的表示和距离函数替换为学习的表示和距离函数，建立了简单的最近邻方案．Siamese 网络通过训练将视频块对分类为相似或不同，并用来找到与所有训练视频块不同的测试视频块，因此判定是异常的．从目标数据集的训练数据中学习一个样本模型......
pytroch【ResNet架构复现】
芊樱烛渊的博客
01-05 225
def conv3x3(in_ , out_ , stride = 1 , initialzero = False) : bn = nn . BatchNorm2d(out_) #需要进行判断，要对BN进行0初始化吗？
pytorch中残差网络resnet的源码解读
热门推荐
ZJE
07-24 2万+
pytorch的resnet模块在torchvision的models中。 里面可以选择的resnet类型有： _all_列表的每一个resnet都提供了实现的函数： def resnet18(pretrained=False, progress=True, **kwargs): """Constructs a ResNet-18 model. Args: ...
Siamese系列跟踪网络之SiamFC、SiamRPN、DaSiamRPN、SiamRPN++、SiamMask
迷路的咸鱼的博客
01-28 1万+
  目前，跟踪领域主要分为两条主线，即基于相关滤波的跟踪算法和基于孪生网络的跟踪算法。由于深度特征的提取和更新很难做到实时，基于在线微调网络的深度目标跟踪方法会使跟踪器的效率大大降低。为解决这一问题，SiamFC提出基于离线端到端训练的全卷积李生网络的跟踪方法，在拥有较快的跟踪速度的同时，保持着较高的跟踪精度，因此受到了广泛的关注，近年来也出现基于此的大量研究。下图就是从SaimFC延伸的发展脉络： Pysot是由商汤视频智能研究小组上传在Github的一个开源项目，由pytorch深度学习框架提供支持，
全卷积FC-Siamese-Networks的目标跟踪matlab仿真+使用文档
10-12
0.版本：Win7+Matlab R2015b+CUDA7.5+vs2013 1.内容：全卷积Siamese-Networks的目标跟踪仿真 2.用处：用于深度学习编程学习 3适合人群：本科，硕士，博士等教研学习使用
第一篇深度学习目标跟踪
03-30
深度学习目标跟踪是一种在视频序列中持续定位特定对象的技术，它在计算机视觉和人工智能领域具有广泛应用，如自动驾驶、监控安全、无人机导航等。王博士的论文聚焦于利用深度学习提升目标跟踪的性能和鲁棒性。 在...
多目标跟踪算法
04-16
深度学习模型能够自动学习目标的特征表示，提高跟踪的准确性和鲁棒性。例如，Siamese网络通过共享的卷积结构对比目标和候选区域的相似性；Tracktor则结合了目标检测和跟踪，以端到端的方式进行训练和预测。 **图像...
跟踪领域比较火的Siamese系列代码
05-11
跟踪领域比较火的Siamese系列代码,包括CFNet Siamese-fc DCFNet 等
Siamese目标跟踪：STMTrack: Template-free Visual Tracking with Space-time Memory Networks(CVPR2021)
du的博客
05-10 4784
论文 STMTrack: Template-free Visual Tracking with Space-time Memory Networks 参考文章 STMTrack 1.Motivation 离线训练的Siam跟踪器已经充分挖掘了第一帧模板信息，但是不能很好地适应目标外观变化。 现有的模板更新机制大多依赖耗时的数值优化或复杂的手工设计策略，但是不能实时跟踪和实际应用。 本文方法速度达到37FPS。 2.Contribution 本文提出了一种基于时空记忆网络的跟踪框架，该框架能够充分利用与目.
Siamese目标跟踪：PG-Net(ECCV2020)
du的博客
05-28 1217
论文 PG-Net: Pixel to Global Matching Network for Visual Tracking 参考文章 [Note24] PG-Net 超越互相关的Pixel to Global Matching 1.Motivation 2.Contribution 3.Method 4.Experiments 5.Conclusion
单目标跟踪 Siamese系列网络：SiamFC、SiamRPN、one-shot跟踪、one-shotting单样本学习、DaSiamRPN、SiamRPN++、SiamMask
あずにゃん梓喵的博客
07-17 6443
日萌社 人工智能AI：Keras PyTorch MXNet TensorFlow PaddlePaddle 深度学习实战（不定时更新） 3.6.Siamese 学习目标： 了解siamase的网络结构 知道one-shotting学习 了解siamase在目标跟踪中的应用 1.Siamese网络 Siamese network就是“连体的神经网络”，神经网络的“连体”是通过共享权值来实现的，如下图所示。共享权值意味着两边的网络权重矩阵一模一样，甚至可以是同一个网络。 如果左右两边.
智慧交通day04-特定目标车辆追踪03：siamese在目标跟踪中的应用-SiamMask(2019)
小李的研究生学习日记
11-22 1万+
与普通的视频跟踪网络不同的是，SiamMask可以同时完成视频跟踪和实例级分割的任务。如下图所示，与传统的对象跟踪器一样，依赖于一个简单的边界框初始化（蓝色）并在线操作。与ECO（红色）等最先进的跟踪器不同，SiamMask（绿色）能够生成二进制分割，从而更准确地描述目标对象。 3.5.1 网络结构 SiamMask的网络结构，提出了三分支的SiamMask网络。与之前的孪生网络十分相似的是，将模板图像与搜索图像输入网络，两者经过特征提取网络，特征提取网络如下表所示，生成15×15×256.
(一)Siamese目标跟踪——SiamFC训练和跟踪过程：从论文细节角度出发
BearLeer的博客
03-21 4883
SiamFC 简单介绍 SiamFC基于深度学习的方法在速度上已经超过传统的相关滤波算法，实时性极强。SiamFC基于孪生网络，该网络有两个输入，一个是模板样本Z，另一个搜索样本X。而在单目标跟踪任务中，模板样本通常选取的是视频序列第一帧中的目标，而候选样本则是之后每一帧中的图像搜索区域（search image）。孪生网络的目的是在后续帧中找到与模板帧Z最相似的候选区域，该区域即为这一帧中的目标。 SiamFC 实现方法 SiamFC网络设计结构如上图所示，其中φ\varphiφ 代表特征提取方法，原文
Fully-Convolutional Siamese Networks for Object Tracking基于全卷积孪生网络的目标跟踪算法SiameseFC
宿莽的专栏
03-12 1万+
1.论文相关Bertinetto, Luca, et al. "Fully-convolutional siamese networks for object tracking." European conference on computer vision. Springer, Cham, 2016.之前写的论文总结更多的偏向于论文翻译，以后写的论文总结要更偏向于总结2.论文内容2.1摘要   ...
Siamese跟踪系列文章汇总
yxyyxy1995的博客
06-25 1230
参考链接 https://zhuanlan.zhihu.com/p/66757733 https://zhuanlan.zhihu.com/p/42546692 Siam FC SiamRPN DaSianRPN SuanRPN ++
三重损失在Siamese网络目标跟踪中的应用
"这篇论文探讨了在目标跟踪中使用Siamese网络和三重损失算法的创新方法。作者提出了一种新的损失函数，用于增强深度特征的表达能力，以提升目标跟踪的准确性。该方法通过在Siamese网络框架内引入三重损失，替代传统...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值