DaSiamRPN测试程序分析

此番开源的 DaSiamRPN 代码不包含文章3.3节中的内容（参见知乎评论），同时公布的 SiamRPNBIG.model 相比论文中的模型通道翻倍，计算量增至原有的4倍。因此，速度亦不可按照原文中考量。该项目的实际内容可以看作是 SiamRPNv2。

SiamRPN 和 DaSiamRPN 基于 AlexNet，Fast R-CNN 中 RPN 基于 ZF-Net。ZF-Net 是 AlexNet 的修改版，这意味着 DaSiamRPN 是在用 RPN 做相关(cross correlation)操作。

SiamRPNBIG

SiamRPNBIG 扩大了搜索区域($255\Rightarrow 271$)，通道数量相比 Siamese-FC 和 SiamRPN 翻倍。

网络计算量（SiamRPNBIG）

Type/Stride	Filter Shape	Input Size	GFLOPs
Conv1 / s2	11x11x3	271x271x3	2.23
MaxPool1 / s2	3x3	131x131x192
Conv2	5x5x192	65x65x192	17.03
MaxPool2 / s2	3x3	61x61x512
Conv3	3x3x512	30x30x512	5.17
Conv4	3x3x768	28x28x768	4.46
Conv5	3x3x512	26x26x512	2.53
reg_d	3x3x512	24x24x512	2.13
cls_d	3x3x512	24x24x512	2.13
Correlation_reg	4x4x512	22x22x512	0.11
Correlation_cls	4x4x512	22x22x512	0.06
regress_adjust	1x1x20	19x19x20	0.0003
total			35.9

torch.nn.Sequential 是顺序容器。模块将按照它们在构造函数中传递的顺序添加到它中。或者，也可以传入模块的有序字典。

    def __init__(self, feat_in=512, feature_out=512, anchor=5):
        super(SiamRPNBIG, self).__init__()
        self.anchor = anchor
        self.feature_out = feature_out
        self.featureExtract = nn.Sequential(
            nn.Conv2d(3, 192, 11, stride=2),
            nn.BatchNorm2d(192),
            nn.ReLU(inplace=True),
            nn.MaxPool2d(3, stride=2),
            nn.Conv2d(192, 512, 5),
            nn.BatchNorm2d(512),
            nn.ReLU(inplace=True),
            nn.MaxPool2d(3, stride=2),
            nn.Conv2d(512, 768, 3),
            nn.BatchNorm2d(768),
            nn.ReLU(inplace=True),
            nn.Conv2d(768, 768, 3),
            nn.BatchNorm2d(768),
            nn.ReLU(inplace=True),
            nn.Conv2d(768, 512, 3),
            nn.BatchNorm2d(512),
        )

conv_r1是模板分支的坐标回归，conv_cls1是其分类；conv_r2和conv_cls2作用于检测分支，只是普通的3x3卷积。但self.r1_kernel的初始化类型值得注意，实际赋值为 Tensor，意味着不是推理所需。作为对比可参考 MathsXDC/DaSiamRPNWithOfflineTraining。

regress_adjust为1x1卷积，在论文中未有提及。

        self.conv_r1 = nn.Conv2d(feat_in, feature_out*4*anchor, 3)
        self.conv_r2 = nn.Conv2d(feat_in, feature_out, 3)
        self.conv_cls1 = nn.Conv2d(feat_in, feature_out*2*anchor, 3)
        self.conv_cls2 = nn.Conv2d(feat_in, feature_out, 3)
        self.regress_adjust = nn.Conv2d(4*anchor, 4*anchor, 1)

        self.r1_kernel = []
        self.cls1_kernel = []

temple

由于孪生网的两个分支在跟踪推理阶段是异步运行，所以 SiamRPNBIG 专门定义了一个 temple 函数来处理模板。

调用featureExtract提取模板z的特征。
由z_f得到坐标回归量r1_kernel_raw和分类得分cls1_kernel_raw。
kernel_size为模板宽度。
torch.Tensor.view 返回一个新的张量，其数据与自身张量相同，但大小不同。
修改r1_kernel和cls1_kernel的形状：
$$[feature\_out\ast 4\ast \mathrm{anchor},kernel\_size,kernel\_size]\Rightarrow [\mathrm{anchor}\ast 4,feature\_out,kernel\_size,kernel\_size]$$
模板分支作为卷积核。
如果是批量训练如何处理呢？

        z_f = self.featureExtract(z)
        r1_kernel_raw = self.conv_r1(z_f)
        cls1_kernel_raw = self.conv_cls1(z_f)
        kernel_size = r1_kernel_raw.data.size()[-1]
        self.r1_kernel = r1_kernel_raw.view(self.anchor*4, self.feature_out, kernel_size, kernel_size)
        self.cls1_kernel = cls1_kernel_raw.view(self.anchor*2, self.feature_out, kernel_size, kernel_size)

forward

torch.nn.Module.forward 定义每次调用时执行的计算。所有子类应该覆盖该函数。

虽然需要在此函数中定义正向传递的配方，但是之后应该调用 Module 实例而不是这个，因为前者负责运行已注册的钩子，而后者默默地忽略它们。

torch.nn.functional.conv2d 在由多个输入平面组成的输入图像上应用 2D 卷积。
如果有参数，使用 torch.nn.Module。torch.nn.functional 使用 torch.Tensor，因此需要指定反向函数。torch.nn.Module 使用torch.autograd.Variable，可以借助 torch.autograd.grad 微分。

坐标回归接regress_adjust1x1卷积。

        x_f = self.featureExtract(x)
        return self.regress_adjust(F.conv2d(self.conv_r2(x_f), self.r1_kernel)), \
               F.conv2d(self.conv_cls2(x_f), self.cls1_kernel)

vot_SiamRPN.py

vot_SiamRPN.py 文件为跟踪的主函数。遵从惯例，其调用 SiamRPN_init 和 SiamRPN_track 两个函数。

import vot
from vot import Rectangle
import sys
import cv2  # imread
import torch
import numpy as np
from os.path import realpath, dirname, join

from net import SiamRPNBIG
from run_SiamRPN import SiamRPN_init, SiamRPN_track
from utils import get_axis_aligned_bbox, cxy_wh_2_rect

创建网络并加载模型。
eval() 设置模块为测试模式。cuda(device=None) 将所有模型参数和缓冲区移动到GPU。torch.load 从文件加载用 torch.save() 保存的对象。load_state_dict() 将state_dict中的参数和缓冲区复制到此模块及其后代中。

# load net
net_file = join(realpath(dirname(__file__)), 'SiamRPNBIG.model')
net = SiamRPNBIG()
net.load_state_dict(torch.load(net_file))
net.eval().cuda()

预热。运行模板和检测分支10次。

# warm up
for i in range(10):
    net.temple(torch.autograd.Variable(torch.FloatTensor(1, 3, 127, 127)).cuda())
    net(torch.autograd.Variable(torch.FloatTensor(1, 3, 255, 255)).cuda())

开始跟踪。
创建一个 VOT 对象。VOT 是 Python 集成 VOT 的基类。
region 将配置消息发送到客户端并接收初始化区域和第一个图像的路径。其返回值为初始化区域。
get_axis_aligned_bbox 将坐标数据转换成 RPN 的格式。

# start to track
handle = vot.VOT("polygon")
Polygon = handle.region()
cx, cy, w, h = get_axis_aligned_bbox(Polygon)

frame 函数从客户端获取帧（图像路径）。

image_file = handle.frame()
if not image_file:
    sys.exit(0)

读取图像并初始化跟踪器。SiamRPN_init 构造状态结构体并运行模板分支。

target_pos, target_sz = np.array([cx, cy]), np.array([w, h])
im = cv2.imread(image_file)  # HxWxC
state = SiamRPN_init(im, target_pos, target_sz, net)  # init tracker

进入跟踪循环。
SiamRPN_track 运行检测分支并更新状态变量。
cxy_wh_2_rect 将坐标转换成矩形框的表示形式。
report 将跟踪结果报告给客户端。

while True:
    image_file = handle.frame()
    if not image_file:
        break
    im = cv2.imread(image_file)  # HxWxC
    state = SiamRPN_track(state, im)  # track
    res = cxy_wh_2_rect(state['target_pos'], state['target_sz'])

    handle.report(Rectangle(res[0], res[1], res[2], res[3]))

SiamRPN_init

TrackerConfig 类定义了跟踪器参数。

    state = dict()
    p = TrackerConfig()
    state['im_h'] = im.shape[0]
    state['im_w'] = im.shape[1]

根据目标和输入图像的大小调整搜索区域。

    if ((target_sz[0] * target_sz[1]) / float(state['im_h'] * state['im_w'])) < 0.004:
        p.instance_size = 287  # small object big search region
    else:
        p.instance_size = 271

根据网络总步长计算出得分图大小。
generate_anchor 构造出以图像中心为原点，格式为[cx, cy, w, h]的锚点矩阵。

    p.score_size = (p.instance_size - p.exemplar_size) / p.total_stride + 1

    p.anchor = generate_anchor(p.total_stride, p.scales, p.ratios, p.score_size)

    avg_chans = np.mean(im, axis=(0, 1))

p.context_amount * sum(target_sz)为填充边界。wc_z和hc_z表示纹理填充后的宽高，s_z为等效边长。

    wc_z = target_sz[0] + p.context_amount * sum(target_sz)
    hc_z = target_sz[1] + p.context_amount * sum(target_sz)
    s_z = round(np.sqrt(wc_z * hc_z))

初始化原型。
get_subwindow_tracking 填充并截取出目标。

    # initialize the exemplar
    z_crop = get_subwindow_tracking(im, target_pos, p.exemplar_size, s_z, avg_chans)

torch.autograd.Variable 包裹张量并记录应用于它的操作。
运行 temple 函数计算模板结果。

    z = Variable(z_crop.unsqueeze(0))
    net.temple(z.cuda())

窗有两种。

    if p.windowing == 'cosine':
        window = np.outer(np.hanning(p.score_size), np.hanning(p.score_size))
    elif p.windowing == 'uniform':
        window = np.ones((p.score_size, p.score_size))
    window = np.tile(window.flatten(), p.anchor_num)

记录并返回状态。

    state['p'] = p
    state['net'] = net
    state['avg_chans'] = avg_chans
    state['window'] = window
    state['target_pos'] = target_pos
    state['target_sz'] = target_sz
    return state

TrackerConfig

exemplar 大小为127，搜索区域大小为271。宽高比有5种，尺度只有1种。

    # These are the default hyper-params for DaSiamRPN 0.3827
    windowing = 'cosine'  # to penalize large displacements [cosine/uniform]
    # Params from the network architecture, have to be consistent with the training
    exemplar_size = 127  # input z size
    instance_size = 271  # input x size (search region)
    total_stride = 8
    score_size = (instance_size-exemplar_size)/total_stride+1
    context_amount = 0.5  # context amount for the exemplar
    ratios = [0.33, 0.5, 1, 2, 3]
    scales = [8, ]
    anchor_num = len(ratios) * len(scales)
    anchor = []
    penalty_k = 0.055
    window_influence = 0.42
    lr = 0.295

SiamRPN_track

从state中获取所需变量。

    p = state['p']
    net = state['net']
    avg_chans = state['avg_chans']
    window = state['window']
    target_pos = state['target_pos']
    target_sz = state['target_sz']

计算扩展后尺寸。

    wc_z = target_sz[1] + p.context_amount * sum(target_sz)
    hc_z = target_sz[0] + p.context_amount * sum(target_sz)
    s_z = np.sqrt(wc_z * hc_z)
    scale_z = p.exemplar_size / s_z
    d_search = (p.instance_size - p.exemplar_size) / 2
    pad = d_search / scale_z
    s_x = s_z + 2 * pad

在前一个目标位置为搜索区域x提取缩放的截图。

    # extract scaled crops for search region x at previous target position
    x_crop = Variable(get_subwindow_tracking(im, target_pos, p.instance_size, round(s_x), avg_chans).unsqueeze(0))

tracker_eval 预测出新的位置和得分。

    target_pos, target_sz, score = tracker_eval(net, x_crop.cuda(), target_pos, target_sz * scale_z, window, scale_z, p)
    target_pos[0] = max(0, min(state['im_w'], target_pos[0]))
    target_pos[1] = max(0, min(state['im_h'], target_pos[1]))
    target_sz[0] = max(10, min(state['im_w'], target_sz[0]))
    target_sz[1] = max(10, min(state['im_h'], target_sz[1]))
    state['target_pos'] = target_pos
    state['target_sz'] = target_sz
    state['score'] = score
    return state

tracker_eval

运行网络的检测分支，得到坐标回归量和得分。

 delta, score = net(x_crop)

torch.Tensor.permute 置换此张量的尺寸。
torch.Tensor.contiguous 返回包含与自张量相同的数据的连续张量。如果自张量是连续的，则此函数返回自张量。
torch.Tensor.numpy 将自张量作为 NumPy ndarray 返回。此张量和返回的 ndarray 共享相同的底层存储。自张量的变化将反映在 ndarray 中，反之亦然。

置换delta，其形状由 N x 4k x H x W 变为4x(kx17x17)。score形状为2x(kx17x17)，并取其后一半结果。

    delta = delta.permute(1, 2, 3, 0).contiguous().view(4, -1).data.cpu().numpy()
    score = F.softmax(score.permute(1, 2, 3, 0).contiguous().view(2, -1), dim=0).data[1, :].cpu().numpy()

$$\begin{array}{rl}{x}_i^{pro}& =x_i^{an}+d{x}_l^{reg}\ast w_l^{an}\\ y_j^{pro}& =y_j^{an}+d{y}_l^{reg}\ast h_l^{an}\\ w_l^{pro}& =w_l^{an}\ast e^{d{w}_l}\\ h_l^{pro}& =h_l^{an}\ast e^{d{h}_l}\end{array}$$
由于p.anchor[:, 0]和p.anchor[:, 1]采用相对坐标，所以delta[0, :]和delta[1, :]表示相对前一帧的中心偏移，而delta[2, :]和delta[3, :]为预测宽高。变量含义不明确。

    delta[0, :] = delta[0, :] * p.anchor[:, 2] + p.anchor[:, 0]
    delta[1, :] = delta[1, :] * p.anchor[:, 3] + p.anchor[:, 1]
    delta[2, :] = np.exp(delta[2, :]) * p.anchor[:, 2]
    delta[3, :] = np.exp(delta[3, :]) * p.anchor[:, 3]

$$\mathrm{penalty}=e^{k\ast \max (\frac{r}{r^{\prime }},\frac{r^{\prime }}{r})\ast \max (\frac{s}{s^{\prime }},\frac{s^{\prime }}{s})}$$
$$\begin{array}{rl}(w+p)\times & (h+p)=s^2\\ p=& \frac{w+h}{2}\end{array}$$

尺寸惩罚。sz 和 sz_wh 分别计算两种输入类型的等效边长。

    def change(r):
        return np.maximum(r, 1./r)

    def sz(w, h):
        pad = (w + h) * 0.5
        sz2 = (w + pad) * (h + pad)
        return np.sqrt(sz2)

    def sz_wh(wh):
        pad = (wh[0] + wh[1]) * 0.5
        sz2 = (wh[0] + pad) * (wh[1] + pad)
        return np.sqrt(sz2)
        
    # size penalty
    s_c = change(sz(delta[2, :], delta[3, :]) / (sz_wh(target_sz)))  # scale penalty
    r_c = change((target_sz[0] / target_sz[1]) / (delta[2, :] / delta[3, :]))  # ratio penalty
    
    penalty = np.exp(-(r_c * s_c - 1.) * p.penalty_k)
    pscore = penalty * score

pscore按一定权值叠加一个窗分布值。找出最优得分的索引。

    # window float
    pscore = pscore * (1 - p.window_influence) + window * p.window_influence
    best_pscore_id = np.argmax(pscore)

获得目标的坐标及尺寸。
delta除以scale_z映射到原图。

    target = delta[:, best_pscore_id] / scale_z
    target_sz = target_sz / scale_z
    lr = penalty[best_pscore_id] * score[best_pscore_id] * p.lr

由预测坐标偏移得到目标中心，宽高进行滑动平均。

    res_x = target[0] + target_pos[0]
    res_y = target[1] + target_pos[1]

    res_w = target_sz[0] * (1 - lr) + target[2] * lr
    res_h = target_sz[1] * (1 - lr) + target[3] * lr

    target_pos = np.array([res_x, res_y])
    target_sz = np.array([res_w, res_h])
    return target_pos, target_sz, score[best_pscore_id]

VOT

Python VOT 集成的基类。区域格式有两种。如果没有 trax，从’images.txt’中逐行读取图像路径，从’region.txt’中读取第一行区域坐标。parse_region 根据输入字符串解析出坐标。

    """ Base class for Python VOT integration """
    def __init__(self, region_format):
        """ Constructor
        Args:
            region_format: Region format options
        """
        assert(region_format in ['rectangle', 'polygon'])
        if TRAX:
            options = trax.server.ServerOptions(region_format, trax.image.PATH)
            self._trax = trax.server.Server(options)

            request = self._trax.wait()
            assert(request.type == 'initialize')
            if request.region.type == 'polygon':
                self._region = Polygon([Point(x[0], x[1]) for x in request.region.points])
            else:
                self._region = Rectangle(request.region.x, request.region.y, request.region.width, request.region.height)
            self._image = str(request.image)
            self._trax.status(request.region)
        else:
            self._files = [x.strip('\n') for x in open('images.txt', 'r').readlines()]
            self._frame = 0
            self._region = convert_region(parse_region(open('region.txt', 'r').readline()), region_format)
            self._result = []

region

返回区域位置。

        return self._region

report

记录结果。

        assert(isinstance(region, Rectangle) or isinstance(region, Polygon))
        if TRAX:
            if isinstance(region, Polygon):
                tregion = trax.region.Polygon([(x.x, x.y) for x in region.points])
            else:
                tregion = trax.region.Rectangle(region.x, region.y, region.width, region.height)
            self._trax.status(tregion, {"confidence" : confidence})
        else:
            self._result.append(region)
            self._frame += 1

frame

如果帧索引超出文件列表返回None，否则对应帧文件。

        if TRAX:
            if hasattr(self, "_image"):
                image = str(self._image)
                del self._image
                return image

            request = self._trax.wait()

            if request.type == 'frame':
                return str(request.image)
            else:
                return None

        else:
            if self._frame >= len(self._files):
                return None
            return self._files[self._frame]

namedtuple() 具有命名字段的元组的工厂函数。命名元组为元组中的每个位置赋予含义，并允许更可读，自我记录的代码。它们可以在使用常规元组的任何地方使用，并且它们添加了按名称而不是位置索引访问字段的功能。

parse_region

Split Strings with Multiple Delimiters?

    tokens = map(float, string.split(','))
    if len(tokens) == 4:
        return Rectangle(tokens[0], tokens[1], tokens[2], tokens[3])
    elif len(tokens) % 2 == 0 and len(tokens) > 4:
        return Polygon([Point(tokens[i],tokens[i+1]) for i in xrange(0,len(tokens),2)])
    return None

get_subwindow_tracking

获取图像及目标信息。

    if isinstance(pos, float):
        pos = [pos, pos]
    sz = original_sz
    im_sz = im.shape

original_sz和sz混用？
original_sz+1实现四舍五入取整。
pos是目标中心点的绝对坐标，c为扩展背景后边界到中心的距离。
left_pad = int(max(0., 0 - context_xmin))，即检查图像块是否超出了图片，计算超出量。

    c = (original_sz+1) / 2
    context_xmin = round(pos[0] - c)  # floor(pos(2) - sz(2) / 2);
    context_xmax = context_xmin + sz - 1
    context_ymin = round(pos[1] - c)  # floor(pos(1) - sz(1) / 2);
    context_ymax = context_ymin + sz - 1
    left_pad = int(max(0., -context_xmin))
    top_pad = int(max(0., -context_ymin))
    right_pad = int(max(0., context_xmax - im_sz[1] + 1))
    bottom_pad = int(max(0., context_ymax - im_sz[0] + 1))

填充使得原点发生改变，获得填充后图像块的坐标。

    context_xmin = context_xmin + left_pad
    context_xmax = context_xmax + left_pad
    context_ymin = context_ymin + top_pad
    context_ymax = context_ymax + top_pad

如果需要填充，首先初始化te_im，再进行对应位置赋值，最后赋给im_patch_original。

    # zzp: a more easy speed version
    r, c, k = im.shape
    if any([top_pad, bottom_pad, left_pad, right_pad]):
        te_im = np.zeros((r + top_pad + bottom_pad, c + left_pad + right_pad, k), np.uint8)  # 0 is better than 1 initialization
        te_im[top_pad:top_pad + r, left_pad:left_pad + c, :] = im
        if top_pad:
            te_im[0:top_pad, left_pad:left_pad + c, :] = avg_chans
        if bottom_pad:
            te_im[r + top_pad:, left_pad:left_pad + c, :] = avg_chans
        if left_pad:
            te_im[:, 0:left_pad, :] = avg_chans
        if right_pad:
            te_im[:, c + left_pad:, :] = avg_chans
        im_patch_original = te_im[int(context_ymin):int(context_ymax + 1), int(context_xmin):int(context_xmax + 1), :]
    else:
        im_patch_original = im[int(context_ymin):int(context_ymax + 1), int(context_xmin):int(context_xmax + 1), :]

如果原始图像块大小与模型输入不同则调用 OpenCV 函数。

    if not np.array_equal(model_sz, original_sz):
        im_patch = cv2.resize(im_patch_original, (model_sz, model_sz))  # zzp: use cv to get a better speed
    else:
        im_patch = im_patch_original

im_to_torch 仅转换轴，BGR 通道顺序和数值（0～255）保持不变。

    return im_to_torch(im_patch) if out_mode in 'torch' else im_patch

generate_anchor

构造锚点数组。
size似乎改成 Receptive Field 更好理解。scale为8，需要根据输入小心设计。

    anchor_num = len(ratios) * len(scales)
    anchor = np.zeros((anchor_num, 4),  dtype=np.float32)
    size = total_stride * total_stride
    count = 0
    for ratio in ratios:
        ws = int(np.sqrt(size / ratio))
        hs = int(ws * ratio)
        for scale in scales:
            wws = ws * scale
            hhs = hs * scale
            anchor[count, 0] = 0
            anchor[count, 1] = 0
            anchor[count, 2] = wws
            anchor[count, 3] = hhs
            count += 1

对锚点组进行广播，并设置其坐标。
加上ori偏移后，xx和yy以图像中心为原点。

    anchor = np.tile(anchor, score_size * score_size).reshape((-1, 4))
    ori = - (score_size / 2) * total_stride
    xx, yy = np.meshgrid([ori + total_stride * dx for dx in range(score_size)],
                         [ori + total_stride * dy for dy in range(score_size)])
    xx, yy = np.tile(xx.flatten(), (anchor_num, 1)).flatten(), \
             np.tile(yy.flatten(), (anchor_num, 1)).flatten()
    anchor[:, 0], anchor[:, 1] = xx.astype(np.float32), yy.astype(np.float32)
    return anchor

参考资料：

• ECCV视觉目标跟踪之DaSiamRPN
• 2018CVPR之siameseRPN
• [深度学习] [目标跟踪] Siamese-RPN论文阅读笔记
• 【目标跟踪】SiameseRPN：High Performance Visual Tracking with Siamese Region Proposal Network
• zkisthebest/Siamese-RPN
• Understanding AlexNet
• 深度学习经典卷积神经网络之AlexNet
• 经典CNN网络 - AlexNet总结
• 卷积神经网络模型解读汇总——LeNet5，AlexNet、ZFNet、VGG16、GoogLeNet和ResNet
• faster-rcnn 之 RPN网络的结构解析
• [CVPR2017] CFNet 论文解读
• cnn模型所需的计算力（flops）是怎么计算的？ - chen liu的回答
• dongfangduoshou123/DaSiamRPN-Caffe2
• MathsXDC/DaSiamRPNWithOfflineTraining