Siamese系列跟踪网络之SiamFC、SiamRPN、DaSiamRPN、SiamRPN++、SiamMask
目前，跟踪领域主要分为两条主线，即基于相关滤波的跟踪算法和基于孪生网络的跟踪算法。由于深度特征的提取和更新很难做到实时，基于在线微调网络的深度目标跟踪方法会使跟踪器的效率大大降低。为解决这一问题，SiamFC提出基于离线端到端训练的全卷积李生网络的跟踪方法，在拥有较快的跟踪速度的同时，保持着较高的跟踪精度，因此受到了广泛的关注，近年来也出现基于此的大量研究。下图就是基于SaimFC改进的发展脉络：
Pysot（https://github.com/STVIR/pysot）是由商汤视频智能研究小组上传在Github的一个开源项目，由pytorch深度学习框架提供支持，这个项目还包含一个评估跟踪器的python工具包端口。Pysot 的目标是为视觉跟踪研究提供高质量、高性能的代码库，十分灵活，便于支持新研究的快速实施和评估。Pysot 包括以下视觉跟踪算法的实现：SiamRPN、DaSiamRPN、SiamRPN++、SiamMask，使用以下骨干网络架构：AlexNet、MobileNetV2、ResNet{18, 34, 50}，评价工具包可以支持的数据集有OTB2015、VOT16/18/19、VOT18-LT、LaSOT、UAV123。
下面，我将结合论文与代码实现来梳理这五个算法。
Siamese系列跟踪网络
- SaimFC (2016)
- SiamRPN (2018)
- DaSiamRPN (2018)
- SiamRPN++ (2019)
- SiamMask (2019)
SaimFC (2016)
《Fully-Convolutional Siamese Networks for Object Tracking》是2016年提出的，最大创新点在于使用全卷积孪生网络进行相似性学习，来解决跟踪任意对象的问题。在孪生网络之前，相关滤波算法使用从视频本身提取的示例以在线方式学习目标外观的模型，但是这些算法的明显缺陷是只能学习相对简单的模型。虽然这个问题可以通过采用从大型监督数据集训练而来的深度卷积网络得到改善，但监督数据的稀缺性和实时操作的限制阻止了深度学习在为每个视频学习一个检测器的范式中应用。
- 网络结构：如上图所示，孪生网络就是用相同的网络结构（AlexNet），对两个输入做相同的变换（ φ \varphi φ），然后学习一个函数 f ( z , x ) = g ( φ ( z ) , φ ( x ) ) f(z, x) = g(φ(z), φ(x)) f(z,x)=g(φ(z),φ(x))，该函数将示例（模板）图像 z z z与候选（搜索）图像 x x x所有可能的位置进行比较，如果在搜索图像上找到了相同的目标，则返回高分，否则返回低分。 φ \varphi φ可以看做特征提取，分别生成了6×6×128和22×22×128的特征图（feature map），再对提取的特征进行互相关操作（即求卷积），生成17×17×1的响应图(heat map)，全卷积的优点是模板图像与搜索图像不需要有相同的尺寸。可以看出，网络最终生成的heat map与输入的255×255搜索区域大小不同，为了实现映射关系，将17×17的响应图进行双三次插值生成272×272的图像来确定物体的位置。
- 训练方式：在正负对上采用判别方法训练网络，使用logistic损失 l ( y , v ) = l o g ( 1 + e x p ( − y v ) ) l(y, v) = log(1 + exp(−yv)) l(y,v)=log(1+exp(−yv))，其中 v v v是单个exemplar-candidate pair的真实得分， y ∈ { + 1 , − 1 } y \in \{+1,-1\} y∈{+1,−1}是其gt的标签，训练过程会忽视目标本身的类别。由于使用较大的搜索图像块，因此训练会得到相应的score map，其损失为 L ( y , v ) = 1 ∣ D ∣ ∑ u ∈ D l ( y [ u ] , v [ u ] ) L(y, v) =\frac1{|D|} \sum_{u \in D}l(y[u],v[u]) L(y,v)=∣D∣1∑u∈Dl(y[u],v[u])，使用SGD优化器进行目标函数的优化 arg max θ E ( z , x , y ) L ( y , f ( z , x ; θ ) ) \underset {\theta}{\operatorname {arg\,max} }\, \underset {(z,x,y)}\mathbb{E}L(y, f (z, x; θ)) θargmax(z,x,y)EL(y,f(z,x;θ))。label的设置为17×17的二值响应矩阵，由于SiamFC是全卷积网络，所以作者没有关心物体在图片中的位置，因此都以中心作为最大响应的地方，并以半径为R的范围限定设置正样本+1， R ＝ k ∣ ∣ u − c ∣ ∣ R＝k||u − c|| R＝k∣∣u−c∣∣， k k k为网络的总步长，其余位置为负样本-1。
- 数据处理：正负样本对是从带注释的视频数据集（ILSVRC2015）中抽取的，成对的样本出自同一视频中不同的两帧，这两帧视频都包含目标物体，而且最多相隔T帧。由于输入图像的尺寸是固定的，因此模板图像和搜索图像分别被缩放到127和255的范围。模板图像需要对目标区域做扩充，即要选取比GT稍大的区域，方法如下：（１）如果bbox的尺寸是 ( w , h ) (w,h) (w,h)， ｗ z = w + w + h 2 , h z = h + w + h 2 ｗ_z=w+\frac{w+h}2,h_z=h+\frac{w+h}2 ｗz=w+2w+h,hz=h+2w+h，由于是左右和上下对称扩增，所以扩增距离 p = w + h 4 p=\frac{w+h}4 p=4w+h。（２）然后，需要根据 s ( w + 2 p ) × s ( h + 2 p ) = A , A = 12 7 2 s(w + 2p) × s(h + 2p) = A,A=127^2 s(w+2p)×s(h+2p)=A,A=1272，先计算原矩形变为正方形的边长 c z = ( w + 2 p ) × ( h + 2 p ) c_z= \sqrt{(w + 2p)×(h + 2p)} cz=(w+2p)×(h+2p)，按尺寸裁剪图像块。（３）再计算出缩放比例 s z s_z sz，进行图像块的resize。对于搜索图像，通过 c x = c z × 255 127 c_x=c_z×\frac{255}{127} cx=cz×127255，可以得到搜索图像剪裁正方形的尺寸，这样可以保证目标的缩放尺寸在一个比例上。裁剪是以目标为中心，当裁剪区域超出图像范围时，缺失部分将填充RGB图像的通道平均值。得到的样本图像对如下所示：
- 测试阶段：始终以第一帧作为模板，通过多尺度测试，得到位置和框的大小，由最好的尺寸和初始帧中的目标框大小确定当前预测框的大小，宽高比保持不变。
参考链接：
[1] https://zhuanlan.zhihu.com/p/107428605
[2] http://geyao1995.com/SiamFC/
SiamFC的数据处理代码实现：
def create_dataset(image, bbox, exemplar_size=127, isntance_size=255, padding=(0,0,0)):
'''
params:
image = cv2.imread(img_path)
bbox = [int(xmin), int(ymin), int(xmax), int(ymax)]
padding = tuple(map(int, np.mean(image, axis=(0, 1))))
'''
target_pos = [(bbox[2] + bbox[0]) / 2., (bbox[3] + bbox[1]) / 2.]
target_size = [bbox[2] - bbox[0], bbox[3] - bbox[1]]
w_z = target_size[1] + 0.5 * sum(target_size) # z means exemplar
h_z = target_size[0] + 0.5 * sum(target_size)
s_z = np.sqrt(w_z * h_z)
# z = crop_image(image, target_pos, s_z, exemplar_size, padding)
scale_z = exemplar_size / s_z # 缩放比例
s_x = instance_size / scale_z
# 但此时原图尺寸可能远不足s_z/s_x或超出，因此需要cropping or padding
# 一般padding选择全图平均值
# x = crop_image(image, target_pos, s_x, exemplar_size, padding)
SiamRPN (2018)
由于SiamFC的问题在于跟踪框不够灵活，而SiamRPN便借鉴了目标检测的RPN结构，让跟踪框更加的准确，并且省去多尺度测试耗费的时间。《High Performance Visual Tracking with Siamese Region Proposal Network》是商汤在CVPR2018上提出的，孪生候选区域生成网络（Siamese region proposal network），简称Siamese-RPN，包含用于特征提取的孪生子网络和候选区域生成网络，其中候选区域生成网络包含分类和回归两条支路。
- 网络结构：如上图所示，用于特征提取的孪生子网络与SiamFC一致，作者仍采用AlexNet，共包含５层卷积。模板和搜索两个分支在CNN中共享参数，将 φ ( z ) , φ ( x ) φ(z), φ(x) φ(z),φ(x)分别表示为孪生子网络的输出特征映射(6×6×256和22×22×256)。RPN网络的两个分支分别进行前景背景分类和proposal回归，每个分支接受Siamese网络的两个输出 φ ( z ) φ(z) φ(z) 和 φ ( x ) φ(x) φ(x)通过卷积层 ( 改变通道维度) 后的特征图作为输入。如果有 k k k 个锚点，网络需要输出 2 k 2k 2k 个分类通道和 4 k 4k 4k 个回归通道，因此先分别将 φ ( z ) φ(z) φ(z)的通道数增加到 [ φ ( z ) ] c l s [φ(z)]_{cls} [φ(z)]cls 和 [ φ ( z ) ] r e g [φ(z)]_{reg} [φ(z)]reg这两个分支，分别通过两个卷积层达到4×4×256×2k和4×4×256×4k。同样， φ ( x ) φ(x) φ(x)也被两个卷积层分成两个分支 [ φ ( x ) ] c l s [φ(x)]_{cls} [φ(x)]cls 和 [ φ ( x ) ] r e g [φ(x)]_{reg} [φ(x)]reg，但保持通道不变20×20×256。黑色☆代表了在分类分支和回归分支上计算相关性： A w × h × 2 k c l s = [ φ ( x ) ] c l s ⋆ [ φ ( z ) ] c l s A w × h × 4 k r e g = [ φ ( x ) ] r e g ⋆ [ φ ( z ) ] r e g A^{cls}_{w×h×2k} = [φ(x)]_{cls} ⋆[φ(z)]_{cls}\\ A^{reg}_{w×h×4k} = [φ(x)]_{reg} ⋆[φ(z)]_{reg} Aw×h×2kcls=[φ(x)]cls⋆[φ(z)]clsAw×h×4kreg=[φ(x)]reg⋆[φ(z)]reg
- 训练方式：在训练阶段，样本对从 密集标注的ILSVRC和稀疏标注的Youtube-BB中以一个不超过100的随机间隔抽取，然后再进行crop等数据处理，模板和检测帧图像来自同一个视频同一个物体的两帧。由于训练回归分支的需要，采用了一些数据增强的方法比如仿射变换。由于对网络进行基于anchors的训练，因此采用了Faster R-CNN中使用的损失函数，分类是cross-entropy loss，回归是smooth L1 loss。 l o s s = L c l s + λ L r e g loss = L_{cls}+ λL_{reg} loss=Lcls+λLreg，其中 L r e g = ∑ i = 0 3 s m o o t h L 1 ( δ [ i ] , σ ) L_{reg} =\sum_{i=0}^3smooth_{L1} (δ[i], σ) Lreg=∑i=03smoothL1(δ[i],σ)， A x , A y , A w , A h A_x , A_y , A_w , A_h Ax,Ay,Aw,Ah代表anchor boxes的中心点和形状， T x , T y , T w , T h T_x , T_y , T_w , T_h Tx,Ty,Tw,Th代表ground truth boxes， δ [ 0 ] = T x − A x A w , δ [ 1 ] = T y − A y A h , δ [ 2 ] = l n T w A w , δ [ 3 ] = l n T h A h δ[0]=\frac{T_x-A_x}{A_w}, δ[1]=\frac{T_y-A_y}{A_h}, δ[2]=ln\frac{T_w}{A_w}, δ[3]=ln\frac{T_h}{A_h} δ[0]=AwTx−Ax,δ[1]=AhTy−Ay,δ[2]=lnAwTw,δ[3]=lnAhTh。在制作分类label的时候，正样本被定义为与其GT的 I o U > t h h i IoU > th_{hi} IoU>thhi的锚框，负样本被定义为与其GT的 I o U < t h l o IoU < th_{lo} IoU<thlo的锚框，论文中设定 t h l o th_{lo} thlo 为0.3， t h h i th_{hi} thhi为0.6，并且限制从一个训练对挑选64个样本，其中最多16个正样本。
- 测试阶段：以初始帧作为模板进行预计算，并在整个跟踪过程中对模板支路的输出进行固定，作为检测器局部的kernels，如下图所示。两个分支输出的分类和回归特征图以点集表示为： A w × h × 2 k c l s = { ( x i c l s , y j c l s , c l c l s ) } ， i ∈ [ 0 , w ) , j ∈ [ 0 , h ) , l ∈ [ 0 , 2 k ) A w × h × 4 k r e g = { ( x i r e g , y j r e g , d x p r e g , d y p r e g , d w p r e g , d h p r e g ) } ， i ∈ [ 0 , w ) , j ∈ [ 0 , h ) , p ∈ [ 0 , k ) A^{cls}_{w×h×2k} = \{(x _i^{cls} , y_j^{cls} , c_l^{cls} )\}，i ∈ [0, w), j ∈ [0, h), l ∈ [0, 2k)\\ A^{reg}_{w×h×4k} = \{(x _i^{reg} , y_j^{reg} , dx_p^{reg} , dy_p^{reg} , dw_p^{reg} , dh_p^{reg} )\}，i ∈ [0, w), j ∈ [0, h), p ∈ [0, k) Aw×h×2kcls={(xicls,yjcls,clcls)}，i∈[0,w),j∈[0,h),l∈[0,2k)Aw×h×4kreg={(xireg,yjreg,dxpreg,dypreg,dwpreg,dhpreg)}，i∈[0,w),j∈[0,h),p∈[0,k)
在分类的得分中找到 l l l为奇数（positive score）中的top K个值 C L S ∗ = { ( x i c l s , y j c l s , c l c l s ) i ∈ I , j ∈ J , l ∈ L } CLS^∗ =\{(x _i^{cls} , y_j^{cls} , c_l^{cls} )_{i∈I,j∈J,l∈L}\} CLS∗={(xicls,yjcls,clcls)i∈I,j∈J,l∈L}，然后找到对应的锚框 A N C ∗ = { ( x i a n , y j a n , w l a n , h l a n ) i ∈ I , j ∈ J , l ∈ L } ANC^∗ =\{(x_ i^{an}, y_ j ^{an}, w_l^{an} , h_l^{an} )_ {i∈I,j∈J,l∈L} \} ANC∗={(xian,yjan,wlan,hlan)i∈I,j∈J,l∈L}和预测的回归值 R E G ∗ = { ( x i r e g , y j r e g , d x l r e g , d y l r e g , d w l r e g , d h l r e g ) i ∈ I , j ∈ J , l ∈ L } REG^∗ = \{(x _i^{reg} , y_j^{reg} , dx_l^{reg} , dy_l^{reg} , dw_l^{reg} , dh_l^{reg} )_{i∈I,j∈J,l∈L}\} REG∗={(xireg,yjreg,dxlreg,dylreg,dwlreg,dhlreg)i∈I,j∈J,l∈L}，将回归值转换为回归框 P R O ∗ = { ( x i p r o , y j p r o , w l p r o , h l p r o ) i ∈ I , j ∈ J , l ∈ L } PRO^∗ =\{(x_i^{pro}, y_ j ^{pro}, w_l^{pro} , h_l^{pro} )_ {i∈I,j∈J,l∈L} \} PRO∗={(xipro,yjpro,wlpro,hlpro)i∈I,j∈J,l∈L}的公式如下：
x p r o = x a n + d x l r e g ∗ w l a n y p r o = y a n + d y l r e g ∗ h l a n w l p r o = w l a n ∗ e d w l h l p r o = h l a n ∗ e d h l x^{pro}= x^{an}+dx_l^{reg}∗ w_l^{an}\\ y^{pro}= y^{an}+dy_l^{reg}∗ h_l^{an}\\ w_l^{pro} = w_l ^{an} ∗ e^{dw_l}\\ h_l^{pro} = h_l ^{an} ∗ e^{dh_l} xpro=xan+dxlreg∗wlanypro=yan+dylreg∗hlanwlpro=wlan∗edwlhlpro=hlan∗edhl
然后，使用一系列proposal selection strategies去挑选最佳回归框：（１）抛弃离中心太远的锚点产生的边框，原因是作者认为邻近帧的目标没有大的移动，所以 discard 策略可以有效地去除离群值。（２）利用余弦窗和尺度变化惩罚对proposals的scores进行re-rank。（３）执行Non-maximum-suppression (NMS)保留最终要选择的回归框。（４）得到最佳tracking box。
参考链接：
[1] 【SOT】Siamese RPN论文解读和代码解析
SiamRPN制作训练数据的关键代码：
# 1.create anchors
def genetate_anchors(self.total_stride, self.base_size, self.scales, self.ratios, self.score_size):
'''
params:
total_stride: 8
base_size: 8
scales:[8,] # anchor最终在原图的基准size = base_size * scale
ratios = [0.33, 0.5, 1, 2, 3]
score_size = 17 # feature map上的像素点感受野大小恰好为127的exemplar size
'''
# 1.计算每个锚点处anchor_num个锚框的宽高尺寸
self.anchor_num = len(self.scales)×len(self.ratios)
ws = int(np.sqrt(base_size * base_size)/ratio)
hs = int(ws * ratio)
w = ws * scale
h = hs * scale
self.anchors = np.zeros((anchor_num, 4), dtype=np.float32)
# 可以得到anchor以(0,0)为中心的[x1, y1, x2, y2]
self.anchors[i][:] = [-w*0.5, -h*0.5, w*0.5, h*0.5]
# 2.在原图上计算锚框位置，进行划分
ori = - (self.score_size // 2) * self.total_stride
# ori = img_center - self.score_size // 2 * self.total_stride
# img_center = self.instance_size//2
cx, cy = np.meshgrid([ori + self.total_stride * dx for dx in range(self.score_size)],\
[ori + self.total_stride * dy for dy in range(self.score_size)])
# meshgrid函数用两个坐标轴上的点在平面上画网格
# 3.整合结果
# 2.create anchor target
def anchor_target(self.anchors, target):
'''
params:
target = [tcx, tcy, tw, th]: ground truth bbox
'''
# 通过坐标转换得到anchors的cx, cy, w, h
# -1 ignore 0 negative 1 positive
cls = -1 * np.ones((self.anchor_num, self.score_size, self.score_size), dtype=np.int64)
delta = np.zeros((4, self.anchor_num, self.score_size, self.score_size), dtype=np.float32)
delta_weight = np.zeros((self.anchor_num, self.score_size, self.score_size), dtype=np.float32)
delta[0] = (tcx - cx) / w
delta[1] = (tcy - cy) / h
delta[2] = np.log(tw / w)
delta[3] = np.log(th / h)
overlap = IOU(anchors, target)
pos = np.where(overlap > cfg.TRAIN.THR_HIGH) # 0.6
neg = np.where(overlap < cfg.TRAIN.THR_LOW) # 0.3
pos, pos_num = select(pos, cfg.TRAIN.POS_NUM) # 16
neg, neg_num = select(neg, cfg.TRAIN.TOTAL_NUM) # 64
cls[pos] = 1
delta_weight[pos] = 1. / (pos_num + 1e-6)
cls[neg] = 0
return cls, delta, delta_weight, overlap
# 3.create sub dataset
class TrkDataset(Dataset):
# ......
def __getitem__(self, index):
# template, search = dataset.get_positive_pair(index)
# get image
template_image = cv2.imread(template[0])
search_image = cv2.imread(search[0])
# get bounding box(like siamFC)
# augmentation
# get labels: cls, delta, delta_weioht, overlap
return {'template': template,
'search': search,
'label_cls': cls,
'label_loc': delta,
'label_loc_weight': delta_weight,
'bbox': np.array(target)
}
SiamRPN网络模块的关键代码：
class UPChannelRPN(RPN):
def __init__(self, anchor_num=5, feature_in=256):
super(UPChannelRPN, self).__init__()
cls_output = 2 * anchor_num
loc_output = 4 * anchor_num
self.template_cls_conv = nn.Conv2d(feature_in,
feature_in * cls_output, kernel_size=3)
self.template_loc_conv = nn.Conv2d(feature_in,
feature_in * loc_output, kernel_size=3)
self.search_cls_conv = nn.Conv2d(feature_in,
feature_in, kernel_size=3)
self.search_loc_conv = nn.Conv2d(feature_in,
feature_in, kernel_size=3)
self.loc_adjust = nn.Conv2d(loc_output, loc_output, kernel_size=1)
def forward(self, z_f, x_f):
# 对模板帧进行升维
cls_kernel = self.template_cls_conv(z_f)
loc_kernel = self.template_loc_conv(z_f)
cls_feature = self.search_cls_conv(x_f)
loc_feature = self.search_loc_conv(x_f)
cls = xcorr_fast(cls_feature, cls_kernel)
loc = self.loc_adjust(xcorr_fast(loc_feature, loc_kernel))
return cls, loc
def xcorr_fast(x, kernel):
"""group conv2d to calculate cross correlation, fast version
"""
batch = kernel.size()[0]
pk = kernel.view(-1, x.size()[1], kernel.size()[2], kernel.size()[3])
px = x.view(1, -1, x.size()[2], x.size()[3])
po = F.conv2d(px, pk, groups=batch)
po = po.view(batch, -1, po.size()[2], po.size()[3])
return po
DaSiamRPN (2018)
《Distractor-aware Siamese Networks for Visual Object Tracking》是在ECCV2018上提出的，DaSiamRPN分析了已有的孪生网络算法提取的特征及其具有的缺点，然后聚焦在训练distractor-aware孪生网络准确且长期的跟踪，主要在数据集扩展、训练方法以及local-to-global搜索策略方面对SiamRPN进行了改进。
-
孪生网络的缺点：首先，大部分孪生网络只能区分前景和非语义背景，语义背景一直被认为是很大的干扰，尤其是当背景杂乱时跟踪性能无法保证。其次，大多数孪生追踪器不能更新模型，虽然他们的简单性和固定模式的性质提升了跟踪速度，但是在跟踪场景下目标发生剧烈的外观变化时，孪生网络失去了在线更新模型的能力。第三，目前的孪生网络采取局部搜索策略，无法处理完全遮挡和超出视野的问题。如下图所示，在背景中差异很大的目标也能获得高分，比如白衣的球员和目标，甚至在SiamFC中一些无关的物体也能获得高分。作者分析了原因：（１）孪生网络提取的特征是根据训练数据的类别进行判别式训练得到的，在 SiamFC 和 SiamRPN 中来自同一视频不同帧的训练数据组成对，对于每个搜索区域的非语义背景占大多数，语义物体和干扰项占少数。因此，这种训练数据不平衡的分布使得训练模型难以学习实例层次的表示，而是倾向于学习前景和背景的区别。（２）在推理过程中，使用最近邻搜索搜索区域中最相似的目标，而在第一帧中被标记的背景信息被忽略，所以相似度最高的目标很有可能是干扰项，而并非目标。
-
数据集扩展：高质量的训练数据是视觉跟踪端到端表征学习成功的关键，作者通过引入一系列的策略来消除训练数据的不平衡分布，从而提高特征的泛化能力。 最初SiamFC是在ILSVRC视频检测数据集上训练，SiamRPN探索使用稀疏标签的Youtube-BB视频，这些视频检测数据集只包含很少的类别(VID 20，Youtube-BB 30) ，这不足以提供高质量和通用的跟踪特征。为了提高泛化能力并且对新类别的边界框回归更加准确，在训练集中增加了正样本对(detection pairs)。为了节省视频标记的繁琐和耗时，直接引入大规模ImageNet Detection和COCO Detection数据集，通过增强技术(平移、调整大小、灰度等) ，检测数据集的静态图像可用于生成图像对进行训练，如下图（a）所示。为了提高判别能力增加了语义负对(negative pairs from the same/different categories)，来自不同类别的负对可以使跟踪器避免在超出视野和完全遮挡时漂移到任意目标，而来自同一类别的负对使得跟踪器专注于细粒度表示，即同类不同物的区分，如下图（b）和（c）所示。
-
Distractor-aware Incremental Learning：作者提出一个干扰-感知模块来有效的将一般表示( general representation)转换到特定视频域(video domain)。为了充分利用标签信息，我们将目标上下文中的负样本(干扰项)集成到相似度量中，采用非最大值抑制(NMS)来选择每帧中的可能的distractors d i d_i di，然后得到一个distractor set D : = { ∀ d i ∈ D , f ( z , d i ) > h ∩ d i ≠ z t } D :=\{∀d_i ∈ D, f (z, d_i ) > h ∩ d_i \not=z_t \} D:={∀di∈D,f(z,di)>h∩di=zt}， ∣ D ∣ = n |D|=n ∣D∣=n，其中 f ( z , x ) f (z, x) f(z,x)是模板和搜索图像的相似性度量， z t z_t zt是第 t t t帧通过最高得分选择的目标， h h h是预先设定好的阈值，来挑选剩下目标中的干扰项。在此基础上，引入一种新的干扰项感知目标函数，对与样本最像的top-k个proposals P P P进行重新排序。最后选择的目标被标记为 q q q： q = arg max p k ∈ P f ( z , p k ) − α ^ ∑ i = 1 n α i f ( d i , p k ) ∑ i = 1 n α i = arg max p k ∈ P ( φ ( z ) − α ^ ∑ i = 1 n α i φ ( d i ) ∑ i = 1 n α i ) ⋆ φ ( p k ) q = \argmax_{p_k ∈P} f (z, p_k )- \frac{\hat{α}\sum_{i=1}^nα_if (d_i , p_k ) }{\sum_{i=1}^n α_i}\\ =\argmax_{p_k ∈P} (φ(z)- \frac{\hat{α}\sum_{i=1}^nα_iφ(d_i) }{\sum_{i=1}^n α_i})⋆φ(p_k) q=pk∈Pargmaxf(z,pk)−∑i=1nαiα^∑i=1nαif(di,pk)=pk∈Pargmax(φ(z)−∑i=1nαiα^∑i=1nαiφ(di))⋆φ(pk)
α ^ \hat{α} α^控制整体干扰项学习的影响， α i α_i αi控制每一个干扰项 d i d_i di的影响，但是直接计算会使计算复杂度和内存占用量增加 n n n倍，因此用第二个等式加速计算，即通过减少卷积的次数来减小计算复杂度。更进一步可以进行增量学习，将现有的相似性度量(general)调整为新领域(specific)的相似性度量。（这里不是很理解，在代码中也没有找到实现过程，/(ToT)/~~） q = arg max p k ∈ P ( ∑ t = 1 T β t φ ( z t ) ∑ t = 1 T β t − ∑ t = 1 T β t α ^ ∑ i = 1 n α i φ ( d i , t ) ∑ t = 1 T β t ∑ i = 1 n α i ) ⋆ φ ( p k ) q =\argmax_{p_k ∈P} (\frac{\sum_{t=1}^T β_tφ(z_t)}{\sum_{t=1}^T β_t}- \frac{\sum_{t=1}^T β_t\hat{α}\sum_{i=1}^nα_iφ(d_{i,t}) }{\sum_{t=1}^T β_t\sum_{i=1}^n α_i})⋆φ(p_k) q=pk∈Pargmax(∑t=1Tβt∑t=1Tβtφ(zt)−∑t=1Tβt∑i=1nαi∑t=1Tβtα^∑i=1nαiφ(di,t))⋆φ(pk)
如下图所示，该算法充分利用了目标和背景信息，有效地抑制了跟踪过程中干扰因素的影响。
-
Long-term Tracking：提出了一种在短期跟踪和跟踪失败情形间简单而有效的切换方法，主要是根据检测分数的变化。如下图所示，SiamRPN的检测分数并不标准，即使在视野外和完全遮挡的情况下仍然很高，所以其倾向于在这些情形下较为武断地找到一个目标，从而导致跟踪漂移。然而在 DaSiamRPN中，检测得分能与跟踪相位的变化更为一致。因此，设计了一种在跟踪失败的情形下，通过local-to-global搜索策略来逐渐增加搜索区域的方法（即将搜索区域的大小以一个恒定的步长迭代增长），从而对目标re-detect。
SiamRPN++ (2019)
在SiameseFC算法之后，基本上孪生网络都使用浅层的AlexNet做为基准特征提取器，直接使用预训练好的深层网络反而会导致跟踪算法精度的下降。由于孪生网络无法利用深层网络，所以仍然跟先进算法相比精度存在差距。《SiamRPN++: Evolution of Siamese Visual Tracking with Very Deep Networks》是商汤在CVPR2019上提出的，对现有的孪生追踪器进行了分析，证明了核心原因是缺乏严格的平移不变性(strict translation invariance)。创新点：（１）提出了一种简单而有效的采样策略，以打破空间不变性限制，成功地训练了基于Resnet架构的孪生跟踪器。（２）提出了一种基于层的互相关运算特征聚合结构(a layer-wise feature aggravation structure)，该结构有助于跟踪器从多个层次的特征中预判出相似度图。（３）提出了一种深度可分离的相关结构(a depth-wise separable correlation structure)，它不仅大大减少了目标模板分支中的参数个数，而且使模型的训练过程更加稳定。
- 孪生网络分析：计算相似度的公式为 f ( x , z ) = φ ( x ) ⋆ φ ( z ) + b f(x,z) = φ(x) ⋆φ(z)+b f(x,z)=φ(x)⋆φ(z)+b，由于相关操作（即以滑窗形式计算每个位置相似度），这意味着两个内在的限制：（１） f ( z , x [ Δ τ j ] ) = f ( z , x ) [ Δ τ j ] f (z, x[\Delta τ_j ]) = f (z, x)[\Delta τ_j] f(z,x[Δτj])=f(z,x)[Δτj]，其中 [ Δ τ j ] [\Delta τ_j] [Δτj]是平移移位子窗口操作器，确保了有效的训练和推理，即推理的时候即使目标不在搜索区域的中心，仍可以具有最大响应。孪生跟踪器中的特征提取需要满足平移不变性，无填充的AlexNet满足这种不变性的限制，而物体检测和语义分割常采用的网络ResNet50，为了保证深层网络分辨率，都具有padding结构，因此提取特征时会将位置信息编码。（２）相似性计算应满足对称性，即 f ( z , x ′ ) = f ( x ′ , z ) f (z, x') = f (x' , z) f(z,x′)=f(x′,z)，而SiamRPN的两个分支要进行前背景分类和偏移量回归，所以网络结构不具有对称性。
如上图所示，通过在带有填充(padding)的网络上进行模拟实验来验证其假设。移位shift定义为数据扩充中均匀分布产生的最大平移范围（0、16和32），在收敛后，将测试数据集上生成的热图集合起来，然后将结果显示在图中。结果表明，在shift为0时（SiamFC训练集中的搜索图像都是以目标为中心），尽管非中心位置会有测试目标的出现，但仍然存在很强的中心偏差。另外两个模拟表明，增加位移范围将逐渐防止模型陷入位置偏见，并且定量分析结果表明，32-shift的总热量更接近于测试对象的位置分布。空间感知抽样策略(spatial aware sampling strategy)，即以均匀分布的采样方式让目标在中心点附近偏移，有效地缓解了填充网络对严格平移不变性的破坏，消除了网络推理时仍总会认为目标出现在中心位置的偏见。更多实验如下，可见适当的移位（±64像素）对于训练深层孪生跟踪器至关重要。
- 基于ResNet的孪生网络跟踪算法：原来的ResNet有32的strides，不适合于密集的孪生网络预测，会影响定位的准确性，通常Siamese网络的strides为８。对ResNet的改变如下图所示，首先，修改block conv4和conv5以获得单位stride，将最后两个blocks的有效步长从16和32减少到8，并通过dilated convolutions增加其感受野。其次，在每个block输出端附加一个额外的1×1卷积层，将通道减少到256，这样后面３个blocks的分辨率和通道就都一致了。最后，由于所有层的填充都保持不变，模板特征的空间大小增加到15，这给相关操作带来了沉重的计算负担。因此，裁剪中心7×7区域作为模板特征，其中每个特征单元仍然可以捕获整个目标区域。
- 按层特征聚合：视觉跟踪需要丰富的表示：层级从低到高、尺度从小到大、分辨率从细到粗，所以即使卷积网络有很深的特征，单独的特征层也是不够的，聚合这些特征可以提高识别和定位的准确性。在网络中，多分支特征被提取出来共同推断目标定位。对于Resnet-50，从最后三个residual blocks中提取多级特性 F 3 ( z ) 、 F 4 ( z ) 和 F 5 ( z ) F_3(z)、F_4(z)和F_5(z) F3(z)、F4(z)和F5(z)，分别输入三个SiamRPN模块，由于三个RPN模块的输出尺寸具有相同的空间分辨率，因此直接在输出上采用加权求和，进行分层聚合。 S a l l = ∑ l = 3 5 α i ∗ S l , B a l l = ∑ l = 3 5 β i ∗ B l . S_{all} = \sum^5_{l=3}α_i ∗ S_l , B_{all} =\sum^5_{l=3}β_i ∗ B_l . Sall=l=3∑5αi∗Sl,Ball=l=3∑5βi∗Bl.上述聚合权重被分开用于分类和回归，并且权重与网络一起进行端到端离线优化。
- Depthwise Cross Correlation：相比于SiamRPN通过添加巨大的卷积层来扩展通道（UP-Xcorr），本文提出了一个轻量级互相关层，名为Depthwise Cross Correlation（DW-XCorr）， DW-XCorr层包含的参数比SiamRPN中使用的UP-XCorr少10倍，而性能却很高。通过这种方式，模板和搜索分支上的参数数量得到平衡，从而使训练过程更加稳定。
经过分层相关操作，作者发现同一类别中的目标在相同的通道上具有高响应（第148通道中的车、第222通道中的人、以及第226通道中的人脸），而其余通道的响应被抑制，原因是深度互相关方式产生的通道特征几乎正交并且每个通道代表一些语义信息。
SiamRPN++网路模块的关键代码：
# ModelBuilder中主要包含三个模块，backbone、neck、rpn_head
x = self.backbone(x)
z = self.backbone(z)
x = self.neck(x)
z = self.neck(z)
cls, loc = self.rpn_head(z, x)
其中，neck是为了将Resnet的layer2/3/4 层的输出（也就是论文图中的conv3/4/5 层）维度进行转换，即512 =>256、1024 =>256、2048 =>256。
# neck.py
class AdjustLayer(nn.Module):
def __init__(self, in_channels, out_channels, center_size=7):
super(AdjustLayer, self).__init__()
self.downsample = nn.Sequential(
nn.Conv2d(in_channels, out_channels, kernel_size=1, bias=False),
nn.BatchNorm2d(out_channels),
) # 使用1×1的卷积核做了downsample
self.center_size = center_size
def forward(self, x):
x = self.downsample(x)
if x.size(3) < 20: # 针对模板帧经过layer234后变为15*15
l = (x.size(3) - self.center_size) // 2
r = l + self.center_size
x = x[:, :, l:r, l:r] # 为了减轻计算量，从中心裁减7×7的区域作为模板特征
return x
然后，rpn_head是用模板作为滤波器的核，与neck得到的三层输出分别进行相关操作，得到的回归和定位预测结果进行加权求和。
class MultiRPN(RPN):
def __init__(self, anchor_num, in_channels, weighted=False):
'''
params:
anchor_num: 5
in_channels: [256, 256, 256]
weighted: true
'''
super(MultiRPN, self).__init__()
self.weighted = weighted
for i in range(len(in_channels)):
self.add_module('rpn'+str(i+2),
DepthwiseRPN(anchor_num, in_channels[i], in_channels[i]))
if self.weighted:
self.cls_weight = nn.Parameter(torch.ones(len(in_channels))) # 3
self.loc_weight = nn.Parameter(torch.ones(len(in_channels))) # 3
# nn.Parameter函数让变量在参数优化的时候可以进行优化以达到最优取值
def forward(self, z_fs, x_fs):
cls = []
loc = []
for idx, (z_f, x_f) in enumerate(zip(z_fs, x_fs), start=2):
rpn = getattr(self, 'rpn'+str(idx))
c, l = rpn(z_f, x_f) # DepthwiseRPN
cls.append(c)
loc.append(l)
if self.weighted:
cls_weight = F.softmax(self.cls_weight, 0)
loc_weight = F.softmax(self.loc_weight, 0)
def avg(lst):
return sum(lst) / len(lst)
def weighted_avg(lst, weight):
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)
else: # 求和平均
return avg(cls), avg(loc)
class DepthwiseRPN(RPN):
def __init__(self, anchor_num=5, in_channels=256, out_channels=256):
super(DepthwiseRPN, self).__init__()
self.cls = DepthwiseXCorr(in_channels, out_channels, 2 * anchor_num)
self.loc = DepthwiseXCorr(in_channels, out_channels, 4 * anchor_num)
# 输入256，隐藏层256，输出分别为2×5=10的分类feature和4×5=20的偏移feature
def forward(self, z_f, x_f):
cls = self.cls(z_f, x_f)
loc = self.loc(z_f, x_f)
return cls, loc
class DepthwiseXCorr(nn.Module):
def __init__(self, in_channels, hidden, out_channels, kernel_size=3, hidden_kernel_size=5):
super(DepthwiseXCorr, self).__init__()
self.conv_kernel = nn.Sequential(
nn.Conv2d(in_channels, hidden, kernel_size=kernel_size, bias=False),
nn.BatchNorm2d(hidden),
nn.ReLU(inplace=True),
)
self.conv_search = nn.Sequential(
nn.Conv2d(in_channels, hidden, kernel_size=kernel_size, bias=False),
nn.BatchNorm2d(hidden),
nn.ReLU(inplace=True),
)
self.head = nn.Sequential(
nn.Conv2d(hidden, hidden, kernel_size=1, bias=False),
nn.BatchNorm2d(hidden),
nn.ReLU(inplace=True),
nn.Conv2d(hidden, out_channels, kernel_size=1)
)
def forward(self, kernel, search):
# 模板帧和搜索帧分别先经过一个3×3的卷积
kernel = self.conv_kernel(kernel)
search = self.conv_search(search)
# 深度可分离卷积
feature = xcorr_depthwise(search, kernel)
# 变维到2k或者4k
out = self.head(feature)
return out
def xcorr_depthwise(x, kernel):
"""depthwise cross correlation
"""
batch = kernel.size(0)
channel = kernel.size(1)
x = x.view(1, batch*channel, x.size(2), x.size(3))
kernel = kernel.view(batch*channel, 1, kernel.size(2), kernel.size(3))
out = F.conv2d(x, kernel, groups=batch*channel) # 通过分组数设置可分离卷积
out = out.view(batch, channel, out.size(2), out.size(3))
return out
对比上述代码可以看出，SiamRPN＋+是先以可分离卷积的方式进行相关操作，在xcorr_depthwise之后经过提升１×１卷积核维度得到2k/4k的输出，而SiamRPN网络是在相关卷积操作之前先提升通道维度，然后进行普通卷积得到2k/4k的输出。
参考链接：PySOT代码之SiamRPN++分析——训练
SiamMask (2019)
视频物体分割（VOS）中物体由一个二元分割mask构成，也就是需要判断某个像素点是否属于目标物体，而视频物体跟踪是定位简单的边框。为了利用跟踪提高视频分割的性能，因此有了与SiamRPN++算法一并在CVPR2019上提出的SiamMask，《Fast Online Object Tracking and Segmentation: A Unifying Approach》，可以同时实现视频目标跟踪和视频目标分割这两个任务，并能达到实时的效果。SiamMask是一个多任务学习算法，每一个任务由一个分支来实现，都基于一个共享的CNN，最后由一个最终损失值汇总计算。
- 网络结构：除了目标相似性评分和边界框坐标偏移量预测之外，全卷积孪生网络还要对RoW(response of a candidate window)所需的信息进行编码，从而产生像素级二进制掩码。通过一个简单的两层神经网络 h ϕ h_ϕ hϕ 和参数 ϕ ϕ ϕ 来预测 w × h w × h w×h 的二元masks(每个RoW对应一个)。用 m n m_n mn 表示对应第n个RoW预测的mask，则 m n = h ϕ ( g θ n ( z , x ) ) m_n = h_ϕ (g_θ^n (z, x)) mn=hϕ(gθn(z,x))。由于现有的孪生网络结构不同，将mask分支加入后分为如下的三分支结构和两分支结构：
其中不同分支的卷积层结构细节如下表所示，左边为三分支，右边为两分支：
1 × 1的卷积允许每一个像素分类利用整个RoW内的信息，从而对候选窗口有着更全面的了解，这可以消除那些与目标物体类似的对象所造成的影响。mask分支经过两层网络 h ϕ h_ϕ hϕ得到(17, 17, 63 × 63)的特征图，然后从17 × 17的map里面根据score分支挑出一个分数最高的RoW用于生成mask，63 × 63 个通道便于还原较大尺寸的mask。有两种方式生成mask，一种是base path直接生成，再有一种是经过refine path。对直接生成而言，（１）对得到的(1, 1, 63 × 63)的RoW重新resize为(63, 63)的矩阵，并对这个矩阵做sigmoid，用于判断这个矩阵的某一个值是否属于目标；（2）通过预设一个分割阈值(比如0.5)，得到一个mask矩阵，矩阵是经过sigmoid后的0-1的值；（3）将这个mask通过仿射变换映射回原图。生成mask之后，回归框可以通过Bbox分支得到，也可以通过mask生成，比如cv2.contour()和cv2.minAreaRect()生成最小外接矩形。为了产生更加准确的mask，refine path通过多个由上采样层和skip connections构成的模块，将低分辨率和高分辨率的特征融合起来。 - Mask refinement module：如下图所示，通过模板帧和候选帧互相关得到了(17, 17, 256)的feature map，然后要从中选一个RoW进行refine path。具体挑选方式为，根据(17, 17, 2×k)的score分支输出，将所有anchor的score做类似于SiamRPN中挑选回归框的一系列操作，如乘上尺度变化惩罚项（size_penalty)，然后从高到低排列选择最大值，根据最大值的index，可以得到(1, 1, 256)的RoW。之后做反卷积(deconv)得到(15, 15, 32)的feature map，与exemplar分支经过Res50提取到的feature进行相加耦合，具体的融合模块U主要包括exemplar分支特征图的通道降维，以及sum融合后上采样到下一尺度大小。
- 训练方式：针对SiamMask的 two-branch 和 three-branch 变体，分别优化多任务损失函数 L 2 B L_{2B} L2B和 L 3 B L_{3B} L3B： L 2 B = λ 1 ⋅ L m a s k + λ 2 ⋅ L s i m L 3 B = λ 1 ⋅ L m a s k + λ 2 ⋅ L s c o r e + λ 3 ⋅ L b o x L_{2B} =λ_1⋅L_{mask}+λ_2⋅L_{sim}\\ L_{3B} =λ_1⋅L_{mask}+λ_2⋅L_{score}+λ_3⋅L_{box} L2B=λ1⋅Lmask+λ2⋅LsimL3B=λ1⋅Lmask+λ2⋅Lscore+λ3⋅Lbox
其中， L m a s k L_{mask} Lmask是一个覆盖所有RoWs的二元logistic回归损失：
L m a s k ( θ , ϕ ) = ∑ n ( 1 + y n 2 w h ∑ i j l o g ( 1 + e − c n i j m n i j ) ) L _{mask}(θ,ϕ)=\sum_n( \frac{1+y_n}{2wh}\sum_{ij}log(1+e^{−c_n^{ij} m_n^{ij} })) Lmask(θ,ϕ)=n∑(2wh1+ynij∑log(1+e−cnijmnij))
每一个RoW都标注有一个ground-truth binary label y n ∈ { ± 1 } y_n \in \{\pm 1\} yn∈{±1}，以及一个像素级的ground-truth mask c n c_n cn，大小是 w × h w\times h w×h， c n i j ∈ { ± 1 } c^{ij}_n ∈ \{±1\} cnij∈{±1}表示第n个RoW的mask里的像素点 ( i , j ) (i, j) (i,j)的标签。 m n m_n mn表示对应第n个RoW预测的mask，上文有提到过。 L m a s k L _{mask} Lmask仅针对正的RoWs考虑（即 y n = 1 y_n=1 yn=1）。
SiamMask网路模块的关键代码：
class MaskCorr(DepthwiseXCorr):
def __init__(self, in_channels, hidden, out_channels,
kernel_size=3, hidden_kernel_size=5):
super(MaskCorr, self).__init__(in_channels, hidden,
out_channels, kernel_size,
hidden_kernel_size)
def forward(self, kernel, search):
kernel = self.conv_kernel(kernel)
search = self.conv_search(search)
feature = xcorr_depthwise(search, kernel)
out = self.head(feature)
return out, feature
从上述代码可以看出，mask分支的结构代码与其他两分支完全相同。
class Refine(nn.Module):
def __init__(self):
super(Refine, self).__init__()
# exemplar branch
self.v0 = nn.Sequential(nn.Conv2d(64, 16, 3, padding=1), nn.ReLU(),
nn.Conv2d(16, 4, 3, padding=1),nn.ReLU()) # channel 64=>4
self.v1 = nn.Sequential(nn.Conv2d(256, 64, 3, padding=1), nn.ReLU(),
nn.Conv2d(64, 16, 3, padding=1), nn.ReLU()) # channel 256=>16
self.v2 = nn.Sequential(nn.Conv2d(512, 128, 3, padding=1), nn.ReLU(),
nn.Conv2d(128, 32, 3, padding=1), nn.ReLU()) # channel 512=>32
# mask branch
self.h2 = nn.Sequential(nn.Conv2d(32, 32, 3, padding=1), nn.ReLU(),
nn.Conv2d(32, 32, 3, padding=1), nn.ReLU())
self.h1 = nn.Sequential(nn.Conv2d(16, 16, 3, padding=1), nn.ReLU(),
nn.Conv2d(16, 16, 3, padding=1), nn.ReLU())
self.h0 = nn.Sequential(nn.Conv2d(4, 4, 3, padding=1), nn.ReLU(),
nn.Conv2d(4, 4, 3, padding=1), nn.ReLU())
self.deconv = nn.ConvTranspose2d(256, 32, 15, 15)
self.post0 = nn.Conv2d(32, 16, 3, padding=1)
self.post1 = nn.Conv2d(16, 4, 3, padding=1)
self.post2 = nn.Conv2d(4, 1, 3, padding=1)
def forward(self, f, corr_feature, pos):
# pos: 根据score分支得到的RoW的位置
# 根据下采样步长将pos对应到不同特征图上，切取在搜索帧上目标特征图大小
p0 = F.pad(f[0], [16, 16, 16, 16])[:, :, 4*pos[0]:4*pos[0]+61, 4*pos[1]:4*pos[1]+61]
p1 = F.pad(f[1], [8, 8, 8, 8])[:, :, 2*pos[0]:2*pos[0]+31, 2*pos[1]:2*pos[1]+31]
p2 = F.pad(f[2], [4, 4, 4, 4])[:, :, pos[0]:pos[0]+15, pos[1]:pos[1]+15]
p3 = corr_feature[:, :, pos[0], pos[1]].view(-1, 256, 1, 1)
out = self.deconv(p3)
out = self.post0(F.upsample(self.h2(out) + self.v2(p2), size=(31, 31)))
out = self.post1(F.upsample(self.h1(out) + self.v1(p1), size=(61, 61)))
out = self.post2(F.upsample(self.h0(out) + self.v0(p0), size=(127, 127)))
out = out.view(-1, 127*127)
return out
参考链接：目标跟踪–Siammask从头到尾的详解