SiamBAN 训练过程debug记录

已于 2022-07-20 10:36:47 修改
阅读量2.2k 收藏 14
点赞数 9
文章标签： 深度学习 机器学习 计算机视觉
于 2022-06-19 21:10:23 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/allrubots/article/details/125102376
版权

目录

一、一些参数的图片展示

1. train.py

 (1) main()

（2）def train

(3) def build_data_loader()

 (4) build_opt_lr

2. model_load.py

(1) def load_pretrain

(2) def remove_prefix

(3) def check_keys

3. dataset.py

 (1) class BANDataset(Dataset)

def shuffle

 (2)class SubDataset(object)

（3）def _filter_zero-->class SubDataset(object)

(4) def shuffle-->class SubDataset(object)

(5) def _find_dataset-->  class BANDataset(Dataset)

 (6) def get_positive_pair-->class SubDataset(object)

 (7)  _get_bbox-->  class BANDataset(Dataset)

4. lr_scheduler.py

(1) def _build_warm_up_scheduler

 (2) class WarmUPScheduler

 5.distributed.py

(1) class DistModule

 (2) broadcast_params

6. model_builder.py

7. augmentation.py

(1)  def __call__

 (2) _shift_scale_aug

8.point_target.py

二、一些关键部分的入口以及代码

1. 搭建主干网络以及构造模型

2. 加载Rsnet预训练骨干的参数 

3. 建立dataset loader

4. 导入数据集的入口

5. 训练时打印的出处

（1） 刚开始准备的阶段

(2) 开头时打印的config内容

 (3) Epoch 啥的

 (4) progress 啥的

(5) 模型的模块结构

6. 数据送入模型的入口

7. 分类标签和回归标签的创建

8. 损失函数的使用

9. 原输入图片为（511，511，3），resize到输入网络的尺寸的入口

10.正样本随机选16个，负样本随机选48个入口

11. 输入shape 通道转成对应的3通道 （3，255，255）以及（3，127，127）入口

12 日志文件创建入口

13. 更改数据集导入路径啥的设置

14. 截取训练数据的入口

15 .最终训练数据的每轮epoch的大小

三、 网络结构

一、一些参数的图片展示

1. train.py

 (1) main()

 optimizer

 lr_scheduler

dist_model

（2）def train

average_meter

 train_loader

data 

outputs

 batch_info (first)

v

 batch_info(second)

 average_meter

 v (batch_info)

(3) def build_data_loader()

train_dataset

 train_sampler

 train_loader

 (4) build_opt_lr

model

 

param

 m

 trainable_params  (first)

 trainable_params  (second)

  trainable_params  (third)

 optimizer

lr_scheduler  (first)

 lr_scheduler  (second)

2. model_load.py

(1) def load_pretrain

第一个

经过remove_prefix后

(2) def remove_prefix

(3) def check_keys

ckpt_keys 

 model_keys

 used_pretrainde_keys

 unused_pretrained_keys

 missing_keys (first)

 missing_keys (secend)

3. dataset.py

 (1) class BANDataset(Dataset)

cfg.DATASET

 《config文件中的设置》

subdata_cfg

self.all_dataset

self.pick

 dataset

 bbox

def shuffle

p， pick

《第一次循环》

 《循环结束后》

 (2)class SubDataset(object)

f

 meta_data (太长了，没截图完)  first

meta_data (second,经过_filter_zero之后的) 

 self.labels

 self.videos

template

 search

 template_box

 search_box

（3）def _filter_zero-->class SubDataset(object)

tracks

(4) def shuffle-->class SubDataset(object)

list

(5) def _find_dataset-->  class BANDataset(Dataset)

dataset

 (6) def get_positive_pair-->class SubDataset(object)

self

 video

 track_info

 (7)  _get_bbox-->  class BANDataset(Dataset)

bbox

4. lr_scheduler.py

(1) def _build_warm_up_scheduler

sc1

 sc2

 (2) class WarmUPScheduler

warmup

 normal

 self.lr_spaces

 5.distributed.py

(1) class DistModule

self.module

 (2) broadcast_params

p

6. model_builder.py

data

 template

 search

 label_cls

 label_loc

 zf 

 xf

 zf (neck)

 xf (neck)

 cls

 loc

 cls (log_softmax)

 cls_loss

 loc_loss

7. augmentation.py

(1)  def __call__

corp_bbox

bbox

 (2) _shift_scale_aug

crop_bbox_center (first)

 crop_bbox_center (second)

 crop_bbox

8.point_target.py

 self.point

points

 [0]

 [1]

cls (first)

 delta (first)

 delta (second)

[0]

 [1]

 [2]

 [3]

 pos

 neg

 position

 cls(second)

二、一些关键部分的入口以及代码

1. 搭建主干网络以及构造模型

train.py------- 267

model = ModelBuilder().cuda().train()

2. 加载Rsnet预训练骨干的参数 

 train.py-----271

    if cfg.BACKBONE.PRETRAINED:  # True
        cur_path = os.path.dirname(os.path.realpath(__file__))  # cur_path: '/root/data/zjx/siamBAN/siamban_ori/tools'
        backbone_path = os.path.join(cur_path, '../', cfg.BACKBONE.PRETRAINED)  # backbone_path:'/root/data/zjx/siamBAN/siamban_ori/tools/../pretrained_models/resnet50.model'
        load_pretrain(model.backbone, backbone_path)

3. 建立dataset loader

train.py----283

train_loader = build_data_loader()

4. 导入数据集的入口

dataset.py -----160

 for name in cfg.DATASET.NAMES:  # name: 'COCO' 这个就是拿出数据集的地方

更精确一点，裁剪后的数据集路径为

dataset.py -----34

 self.root = os.path.join(cur_path, '../../', root)  # '/root/data/zjx/siamBAN/siamban_ori/siamban/datasets/../../training_dataset/coco/crop511'

5. 训练时打印的出处

（1） 刚开始准备的阶段

“======================”
{'000000':[1.08,187.69,612.6700000000001,473.53]}
“======================”

dataset.py-----73

            for trk, frames in tracks.items():  # trk={str}'00'  frames={dict:1}{'000000':[1.08,187.69,612.6700000000001,473.53]}
                print("===================")
                print(frames)
                print("===================")

这些都是准备阶段，还没开始对数据集进行训练呢。

(2) 开头时打印的config内容

 train.py-----264

 logger.info("config \n{}".format(json.dumps(cfg, indent=4)))

 (3) Epoch 啥的

train.py-----241

                for cc, (k, v) in enumerate(batch_info.items()):  # cc:索引， （k，v）与之前的一样
                    if cc % 2 == 0:
                        info += ("\t{:s}\t").format(
                                getattr(average_meter, k))  # ’Epoch:[1][20/17857] lr:0.0010000\n\tbatch_time:1.308527(1.368259)\t‘
                    else:
                        info += ("{:s}\n").format(
                                getattr(average_meter, k))  # ’Epoch:[1][20/17857] lr:0.0010000\n\tbatch_time:1.308527(1.368259)\tdata_time:0.488958(0.661270)\n‘
                logger.info(info)

 (4) progress 啥的

 log_helper.py-----102

 logger.info('Progress: %d / %d [%d%%], Speed: %.3f s/iter, ETA %d:%02d:%02d (D:H:M)\n' %
                (i, n, i / n * 100,
                 average_time,
                 remaining_day, remaining_hour, remaining_min))

(5) 模型的模块结构

 train.py-----166

logger.info("model\n{}".format(describe(model.module)))

6. 数据送入模型的入口

train.py-----202

 outputs = model(data)

7. 分类标签和回归标签的创建

dataset.py-----272

cls, delta = self.point_target(bbox, cfg.TRAIN.OUTPUT_SIZE, neg)

8. 损失函数的使用

module_builder.py-----93

cls = self.log_softmax(cls)  # 先取softmax然后再log，值都为负数， Tensor:(28,25,25,2) <c>
cls_loss = select_cross_entropy_loss(cls, label_cls)  #  <c> 一个数 tensor(0.7612)

# loc loss with iou loss
loc_loss = select_iou_loss(loc, label_loc, label_cls)

9. 原输入图片为（511，511，3），resize到输入网络的尺寸的入口

dataset.py----261

template, _ = self.template_aug(template_image,
                                        template_box,
                                        cfg.TRAIN.EXEMPLAR_SIZE,
                                        gray=gray)  # ndarry:(127,127,3)

        search, bbox = self.search_aug(search_image,
                                       search_box,
                                       cfg.TRAIN.SEARCH_SIZE,
                                       gray=gray)

augmentation.py-----126

image, bbox = self._shift_scale_aug(image, bbox, crop_bbox, size)

10.正样本随机选16个，负样本随机选48个入口

point_target.py---23

 def select(position, keep_num=16):  # keep_num 16 或 48
            num = position[0].shape[0]  # 举例 569
            if num <= keep_num:
                return position, num
            slt = np.arange(num)  # 举例 ndarray:(569:)  [0~568]
            np.random.shuffle(slt)  # 打乱
            slt = slt[:keep_num]  # ndarray:(48,)
            return tuple(p[slt] for p in position), keep_num

11. 输入shape 通道转成对应的3通道 （3，255，255）以及（3，127，127）入口

dataset.py----273

template = template.transpose((2, 0, 1)).astype(np.float32)  # ndarray:(3,127,127)
search = search.transpose((2, 0, 1)).astype(np.float32)

12 日志文件创建入口

train.py-----259

 if cfg.TRAIN.LOG_DIR:  # True
            add_file_handler('global',
                             os.path.join(cfg.TRAIN.LOG_DIR, 'logs.txt'),
                             logging.INFO)

13. 更改数据集导入路径啥的设置

config.py-----129

__C.DATASET.NAMES = ('VID', 'YOUTUBEBB', 'DET', 'COCO', 'GOT10K', 'LASOT')

__C.DATASET.VID = CN()
__C.DATASET.VID.ROOT = 'training_dataset/vid/crop511'
__C.DATASET.VID.ANNO = 'training_dataset/vid/train.json'
__C.DATASET.VID.FRAME_RANGE = 100
__C.DATASET.VID.NUM_USE = 100000

__C.DATASET.YOUTUBEBB = CN()
__C.DATASET.YOUTUBEBB.ROOT = 'training_dataset/yt_bb/crop511'
__C.DATASET.YOUTUBEBB.ANNO = 'training_dataset/yt_bb/train.json'
__C.DATASET.YOUTUBEBB.FRAME_RANGE = 3
__C.DATASET.YOUTUBEBB.NUM_USE = 200000

__C.DATASET.COCO = CN()
__C.DATASET.COCO.ROOT = 'training_dataset/coco/crop511'
__C.DATASET.COCO.ANNO = 'training_dataset/coco/train2017.json'
__C.DATASET.COCO.FRAME_RANGE = 1
__C.DATASET.COCO.NUM_USE = 100000

__C.DATASET.DET = CN()
__C.DATASET.DET.ROOT = 'training_dataset/det/crop511'
__C.DATASET.DET.ANNO = 'training_dataset/det/train.json'
__C.DATASET.DET.FRAME_RANGE = 1
__C.DATASET.DET.NUM_USE = 200000

__C.DATASET.GOT10K = CN()
__C.DATASET.GOT10K.ROOT = 'training_dataset/got_10k/crop511'
__C.DATASET.GOT10K.ANNO = 'training_dataset/got_10k/train.json'
__C.DATASET.GOT10K.FRAME_RANGE = 100
__C.DATASET.GOT10K.NUM_USE = 200000

__C.DATASET.LASOT = CN()
__C.DATASET.LASOT.ROOT = 'training_dataset/lasot/crop511'
__C.DATASET.LASOT.ANNO = 'training_dataset/lasot/train.json'
__C.DATASET.LASOT.FRAME_RANGE = 100
__C.DATASET.LASOT.NUM_USE = 200000

__C.DATASET.VIDEOS_PER_EPOCH = 1000000

14. 截取训练数据的入口

训练数据所用的图片（这里对应处理前的单张图片，处理后成为一个文件夹，依据所包含目标数量多少下面可能包含多张图片）的数量为设置的，self.use_num，若大于这个数则随机截取，小于这个则随机会重复选取直至满足

dataset.py-----66 、98

 self.pick = self.shuffle()
    def shuffle(self):
        lists = list(range(self.start_idx, self.start_idx + self.num))  #  {list:117266} 从0到117265，并且转成列表 <c>
        pick = []
        while len(pick) < self.num_use:  # 小于 使用的数量则循环 。若self.num_use小于lists 的长度则一次循环结束，截取这么长;若大于，则循环执行直至满足
            np.random.shuffle(lists)  # 随机打乱列表中的 索引顺序
            pick += lists
        return pick[:self.num_use]

15 .最终训练数据的每轮epoch的大小

可以一次性使用多个训练数据集，因为每轮epoch的总batch训练大小为20000000个，个数不够循环来凑。

dataset.py-----198

    def shuffle(self):
        pick = []
        m = 0
        while m < self.num:  # 当m 小于时一直执行这个循环
            p = []
            for sub_dataset in self.all_dataset:
                sub_p = sub_dataset.pick  # {list：100000}
                p += sub_p  # 如果是单个数据集的话，p每次都是那些
            np.random.shuffle(p)
            pick += p
            m = len(pick)
        logger.info("shuffle done!")
        logger.info("dataset length {}".format(self.num))
        return pick[:self.num]

16 . 保存模型参数

 train.py -----172

            if get_rank() == 0:  # 只在进程0上保存就行了，避免重复，而且保存的参数为 model.module
                torch.save(
                        {'epoch': epoch,
                         'state_dict': model.module.state_dict(),
                         'optimizer': optimizer.state_dict()},
                        cfg.TRAIN.SNAPSHOT_DIR+'/checkpoint_e%d.pth' % (epoch))

三、 网络结构

ModelBuilder(
  (backbone): 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)
      )
    )
  )
  (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)
      )
    )
  )
  (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))
        )
      )
    )
  )
)

匿名的魔术师
关注
  • 9
    点赞
  • 踩
  • 14
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 104
    评论
Pysot非官方改进PysotPlus，集成SiamBAN
u011609063的博客
09-15 384
PysotPlus说明 说明 非常感谢SenseTime开源的PySOT框架。本人在PySOT的基础上加入了一些东西。项目地址：PysotPlus 1.将SiamBAN集成进该项目 2.加入混合精度训练 3.修改评测工具加载的txt文件，使其能支持逗号，空格和tab三种格式的txt文件 4.使用optuna完成超参搜索 5. 增加一些脚本使其能更方便的使用 6. 使用visdom可视化heatmap 7. 评价工具支持可视化，并且能额外测试TrackingNet, GOT10K 如果大家对该工程有任何疑问，
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
SiamRN：Learning to Filter: Siamese Relation Network for Robust Tracking模型结构和代码解读
Soonki的博客
06-07 437
利用Head产生的cls和loc作用于特征图xf和原图x，产生新的特征图和gt，然后放入Relation Detector中，训练一个加权矩阵(或者说：过滤？Relation Detector的结果直接乘上用来Classify的feature（就是Xcorr），就是加权了。这里放上代码结构图，同时也是SiamRN网络结构图，基本上看这个可以达到复现的效果。个点的矩阵，包含了正样本1（16个），负样本0（48个），忽略样本 -1（外面的所有点都是负样本点，而大椭圆。(没用到)有什么区别。
SiamBAN
qq_38680752的博客
11-13 4276
3. SiamBAN 框架         在本节中，我们将描述建议的SiamBAN框架。如图2所示，SiamBAN由一个Siamese网络主干网和多个box自适应磁头组成。Siamese网络主干负责计算模板块和搜索块的卷积特征映射，它使用了现成的卷积网络。box自适应头包括分类模块和回归模块。具体来说，分类模块对相关层的每个点进行前-背景分类，回归模块对对应位置进行包围盒预测。 图2：提出的box自适应网络的架构。左图为其主
SiamBAN详细分析，一看就懂！
热门推荐
cxkyxx的博客
10-04 1万+
整体把握 SiamBAN是今年CVPR中效果最好的跟踪器之一，研究它的原理更加能够很好的帮助我们掌握目前跟踪器发展的趋势。 SIamBAN，按照意思分析是孪生自适应框。“孪生”，说明该跟踪使用了Siamese网络架构；而“自适应框”，则是该跟踪器采用了anchor-free的策略，不预先设定anchor框的尺寸，使得框拥有更大强大的自由度。 通过分析论文和代码，我认为SiamBAN就是一个优化版的SiamRPN++，最大的创新点在于anchor-free的引用，去掉了预定义的anchor，从而使得模型整体的
训练SiamBAN报错问题
qwerasdzz的博客
05-07 1457
我是用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
mysql过程，函数debug工具
08-30
mysql过程，函数debug工具
存储过程debug工具
11-01
存储过程debug工具
Spring Boot Debug调试过程图解
08-25
Spring Boot Debug 调试过程图解 Spring Boot Debug 调试过程图解是指在 Spring Boot 项目中进行调试的过程图解。通过示例代码，详细介绍了 Spring Boot Debug 调试过程图解，对大家的学习或者工作具有一定的参考...
上机过程及DEBUG命令练习
06-29
上机过程及DEBUG命令练习 本实验报告主要介绍了上机过程及DEBUG命令的练习，旨在帮助学生掌握汇编语言程序的上机过程和DEBUG命令的使用方法。 实验目的： 1. 了解宏汇编语言程序上机的一般过程。 2. 掌握汇编语言...
Pycharm debug调试时带参数过程解析
09-18
主要介绍了Pycharm debug调试时带参数过程解析,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
CVPR-2020-SiamBAN:Siamese Box Adaptive Network for Visual Tracking阅读笔记
菜菜子hoho的博客
05-19 1210
论文地址：https://arxiv.org/pdf/2003.06761.pdf 论文代码：https://github.com/hqucv/siamban 一、 动机： 现有的追踪器大多依赖于多尺度测试和预定义的锚框来对目标进行精确地位，但这样就需要先验知识和一系列设计候选盒子的超参数，所以为了解决这个问题设计了更加灵活通用的SiamBAN。该算法将视觉跟踪问题视为一个并行分类和回归问题，直接对目标进行分类，并在统一的FCN中回归其边界框。并且，神经科学家已经表明，生物视觉初级视觉皮层可以快速有效地从复
CVPR-2020-SiamAttn: Deformable Siamese Attention Networks for Visual Object Tracking 阅读笔记
菜菜子hoho的博客
10-11 2693
目录一、 动机二、 主要贡献三、 主要内容1、Siamese-based Trackers2、Deformable Siamese Attention ModuleSelf-AttentionCross-AttentionDeformable AttentionRegion Proposals3、Region Refinement Module4、Training Loss四、 实验结果五、 结论 论文地址： https://openaccess.thecvf.com/content_CVPR_2020/p
Siamese Box Adaptive Network for Visual Tracking --Siamban,CVPR2020单目标跟踪开源
weixin_45032769的博客
05-31 4666
论文链接 :　http://xxx.itp.ac.cn/pdf/2003.06761v2.pdf 开源项目：https://github.com/hqucv/siamban 创新点:siamban框架 改进:准确估计目标的尺度和纵横比 由于RPN引入导致的参数复杂性 Abstract 现有的跟踪器大多依赖于多尺度搜索方案或预定义的锚来精确估计目标的尺度和纵横比(the scale and aspect ratio of a target)。不幸的是，它们通常需要无脑的启发式配置。为了解决这个问题，我们提出了
Pysot训练自己的数据集
qq_40313336的博客
04-18 5142
SiamRPN++训练自己数据集流程（预处理已完成）
[VOT2](2020CVPR)SiamBAN: Siamese Box Adaptive Network for Visual Tracking
m0_37412775的博客
04-02 8511
Abstract 动机： 已有的大部分追踪器要么依赖于多尺度搜索要么依赖于预设的anchor boxes，以精确估计目标的尺度和比例。但是，他们经常需要繁杂和启发式的配置。 做法：本文提出一个简单但有效的追踪框架SaimBAN，探索全卷积网络(FCN)的表达能力。SaimBAN将视觉追踪问题看作是分类和回归的并行问题，直接以一种统一的FCN方式分类前景和背景并回归目标框。这种无先验框的设计避免了与候选框相关的超参数，使得SiamBAN 更加灵活和通用。 实验：VOT2018, VOT2019, OTB100
计算模型中的可训练参数数量：print_trainable_parameters【参考LoRA】
最新发布
u013250861的博客
06-14 968
【代码】计算模型中的可训练参数数量：print_trainable_parameters【参考LoRA】
pysot-master-train.py 运行记录
qq_42548064的博客
11-12 645
目标跟踪双卡训练
Python hydra库(OmegaConf)(yaml)
hxxjxw的博客
03-06 4212
Python hydra库
训练网络 debug断点加那里
06-10
在训练网络时，可以在代码中添加debug断点以调试代码。通常，可以在代码中的关键部分（例如模型定义、数据加载、损失函数计算等）添加断点，以便在代码执行到该处时暂停。在Python中，可以使用pdb模块添加断点。具体方法是在代码中添加以下代码： ``` import pdb; pdb.set_trace() ``` 当代码执行到这一行时，程序会自动暂停，并进入pdb调试模式，允许你逐行执行代码，并查看变量的值和计算结果。使用命令"n"来执行下一行代码，"q"来退出调试模式，"p variable_name"来查看变量的值，等等。通过这种方式，可以快速定位和修复代码中的错误。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 104
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

匿名的魔术师

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

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

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

打赏作者

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

抵扣说明：

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

余额充值