SiameseFC-TensorFlow 代码详细注解（二）：训练数据VID2015预处理

最新推荐文章于 2023-07-12 16:16:53 发布
最新推荐文章于 2023-07-12 16:16:53 发布
阅读量509 收藏
点赞数 1
分类专栏： siamese
原文链接：https://blog.csdn.net/StayFoolish_Fan/article/details/80432531
版权
原

SiameseFC-TensorFlow 代码详细注解（二）：训练数据VID2015预处理

2018年05月27日 11:01:34 阅读数 5375 更多
分类专栏： Python 目标跟踪 SiameseFC
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接： https://blog.csdn.net/StayFoolish_Fan/article/details/80432531

说明：该系列博客源码链接为：https://github.com/bilylee/SiamFC-TensorFlow，是实验室同小组的师兄用TensorFlow实现SiameseFC算法的最终公开版本，经过了长时间的打磨，各个模块功能明确，整体可读性和可移植性极好，我相信这对做Tracking的小伙伴来说，是个入门SiameseFC Tracker的特别好的选择。哈哈，觉得代码很棒的小伙伴们可以点个Star哦，也欢迎交流学习和指教。

上一篇介绍跑SiameseFC代码的主要流程，这一篇主要介绍开始训练自己的模型的第一步：训练数据预处理。

1：VID2015相关链接

ImageNet比赛官网 ：http://image-net.org/challenges/LSVRC/，可以了解比赛信息，包含各比赛实验数据。

VID2015数据下载链接：http://bvisionweb1.cs.unc.edu/ilsvrc2015/download-videos-3j16.php#vid

2：ILSVRC2015 VID数据

解压缩之前，数据大小约86G，解压缩之后的文件夹目录如下：


ImageSets：包含一些.txt文件，子数据集的相关描述，预处理过程中用不到，可忽略。

Data ：存储的所有数据信息，包括了图片（val,train,test）和视频片段（snippets）。

Annotations：对应的Data中图片的注释信息，包括val和train部分。

Data子文件夹VID下的文件目录如下：


查看当前文件目录下的文件数量命令：（R代表包含子目录）

ls -lR|grep"^-"| wc -l

可通过上面的指令进入到对应的文件夹中统计VID数据的详细信息如下：

Snippets :  3862+ 555 + 937 = 5354 videos

Train       :   3862  videos  ( 1122397 images )

Val          :   555    videos  ( 176126   images )

Test         :   937    videos  ( 315175   images )


Annotations子文件夹VID下的文件目录如下：


只包含了val和train部分，和上面Data/VID/val和train相对应，存储的是每个图片的.xml格式的标注信息。

挑出来一个.xml文件看看里面长什么样，如下：


.xml注释文件有我们需要用到的folder,filename,size,trackid,bndbox等信息，后面会解析出相关的信息的，说明一下这个trackid很重要，同一个image中有多个trackid说明包含该image的短视频存在着很多个目标，在后面就会解析出来更多的videos，记住这点对看后面的数据处理有帮助。

3：VID2015训练数据预处理

我们下载了VID数据之后也知道数据长什么样了，那如何处理这些数据使得可供SiameseFC训练呢？第一步就需要按照SiameseFC论文中Data Curation的部分对数据进行预处理，接着将训练数据存储为.pickle文件方便训练加载，最后还需要下载一些预训练模型和一个测试的视频，详细内容参见下面的注解。

3.1 Data Curation

核心文件：scripts/preprocess_VID_data.py

核心功能：根据SiamsesFC论文中的Curation方式进行图片预处理。


     
     
  1. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
    
         
         #! /usr/bin/env python
        
        
    
       
       
  2. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
    
         
         # -*- coding: utf-8 -*-
        
        
    
       
       
  3. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
    
         
         #
        
        
    
       
       
  4. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
    
         
         # Copyright © 2017 bily     Huazhong University of Science and Technology
        
        
    
       
       
  5. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
    
         
         #
        
        
    
       
       
  6. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
    
         
         # Distributed under terms of the MIT license.
        
        
    
       
       
  7. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
     
        
        
    
       
       
  8. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
    
         
         from __future__ 
         
         import absolute_import
        
        
    
       
       
  9. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
    
         
         from __future__ 
         
         import division
        
        
    
       
       
  10. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
    
         
         from __future__ 
         
         import print_function
        
        
    
       
       
  11. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
     
        
        
    
       
       
  12. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
    
         
         import os
        
        
    
       
       
  13. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
    
         
         import os.path 
         
         as osp
        
        
    
       
       
  14. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
    
         
         import sys
        
        
    
       
       
  15. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
    
         
         import xml.etree.ElementTree 
         
         as ET   
         
         # 解析xml文件的模块
        
        
    
       
       
  16. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
    
         
         from glob 
         
         import glob
        
        
    
       
       
  17. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
    
         
         from multiprocessing.pool 
         
         import ThreadPool   
         
         # 多进程加速
        
        
    
       
       
  18. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
    
         
         import cv2
        
        
    
       
       
  19. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
    
         
         from cv2 
         
         import imread, imwrite     
         
         # 使用 opencv 读写图像
        
        
    
       
       
  20. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
     
        
        
    
       
       
  21. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
    
         
         CURRENT_DIR = osp.dirname(__file__)
        
        
    
       
       
  22. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
    
         
         ROOT_DIR = osp.join(CURRENT_DIR, 
         
         '..')
        
        
    
       
       
  23. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
    
         
         sys.path.append(ROOT_DIR)   
         
         # 添加搜索路径
        
        
    
       
       
  24. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
     
        
        
    
       
       
  25. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
    
         
         from utils.infer_utils 
         
         import get_crops, Rectangle, convert_bbox_format  
         
         # 自己写的小函数
        
        
    
       
       
  26. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
    
         
         from utils.misc_utils 
         
         import mkdir_p                                                                       
        
        
    
       
       
  27. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
     
        
        
    
       
       
  28. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
    
         
         def get_track_save_directory(save_dir, split, subdir, video):   
         
         # 存储路径的一个简单映射函数，简化存储目录
        
        
    
       
       
  29. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
    
         
           subdir_map = {
         
         'ILSVRC2015_VID_train_0000': 
         
         'a',   
         
         # 将train映射到（a,b,c,d），val映射到（e）
        
        
    
       
       
  30. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
                    
         
         'ILSVRC2015_VID_train_0001': 
         
         'b',
        
        
    
       
       
  31. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
                    
         
         'ILSVRC2015_VID_train_0002': 
         
         'c',
        
        
    
       
       
  32. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
                    
         
         'ILSVRC2015_VID_train_0003': 
         
         'd',
        
        
    
       
       
  33. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
                    
         
         '': 
         
         'e'}
        
        
    
       
       
  34. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
      
         
         return osp.join(save_dir, 
         
         'Data', 
         
         'VID', split, subdir_map[subdir], video)   
        
        
    
       
       
  35. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
     
        
        
    
       
       
  36. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
     
        
        
    
       
       
  37. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
    
         
         def process_split(root_dir, save_dir, split, subdir='', ):   
         
         # 数据处理核心函数，spilt就是['val','train']中的值
        
        
    
       
       
  38. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
    
         
           data_dir = osp.join(root_dir, 
         
         'Data', 
         
         'VID', split)                   
         
         # 待处理图片数据路径
        
        
    
       
       
  39. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
    
         
           anno_dir = osp.join(root_dir, 
         
         'Annotations', 
         
         'VID', split, subdir)    
         
         # 待处理图片的注释数据路径
        
        
    
       
       
  40. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
    
         
           video_names = os.listdir(anno_dir)     
         
         # train和val数据集所有的video names，因为我们只有这两个数据集的annotations
        
        
    
       
       
  41. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
     
        
        
    
       
       
  42. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
      
         
         for idx, video 
         
         in enumerate(video_names):
        
        
    
       
       
  43. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
    
         
             print(
         
         '{split}-{subdir} ({idx}/{total}): Processing {video}...'.format(split=split, subdir=subdir,
        
        
    
       
       
  44. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
    
         
                                                                                    idx=idx, total=len(video_names),
        
        
    
       
       
  45. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
    
         
                                                                                    video=video))
        
        
    
       
       
  46. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
    
         
             video_path = osp.join(anno_dir, video)
        
        
    
       
       
  47. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
    
         
             xml_files = glob(osp.join(video_path, 
         
         '*.xml'))  
         
         # 获得当前video的所有图片对应的.xml文件
        
        
    
       
       
  48. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
     
        
        
    
       
       
  49. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
        
         
         for xml 
         
         in xml_files:     
         
         # 使用ET处理单个图片(.jpeg && .xml)
        
        
    
       
       
  50. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
    
         
               tree = ET.parse(xml)                                               
        
        
    
       
       
  51. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
    
         
               root = tree.getroot()
        
        
    
       
       
  52. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
     
        
        
    
       
       
  53. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
    
         
               folder = root.find(
         
         'folder').text                  
         
         # 解析.xml文件的folder
        
        
    
       
       
  54. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
    
         
               filename = root.find(
         
         'filename').text              
         
         # 解析.xml文件中的filename
        
        
    
       
       
  55. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
     
        
        
    
       
       
  56. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
          
         
         # Read image
        
        
    
       
       
  57. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
    
         
               img_file = osp.join(data_dir, folder, filename + 
         
         '.JPEG')      
         
         # 将.xml文件名对应到相同的图片文件名
        
        
    
       
       
  58. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
    
         
               img = 
         
         None
        
        
    
       
       
  59. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
     
        
        
    
       
       
  60. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
          
         
         # Get all object bounding boxes
        
        
    
       
       
  61. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
    
         
               bboxs = []
        
        
    
       
       
  62. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
          
         
         for object 
         
         in root.iter(
         
         'object'):           
         
         # 找到所有的objects
        
        
    
       
       
  63. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
    
         
                 bbox = object.find(
         
         'bndbox')               
         
         # 找到 box项，.xml文件中名称是bndbox
        
        
    
       
       
  64. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
    
         
                 xmax = float(bbox.find(
         
         'xmax').text)       
         
         # 找到对应的 xmax并转换为float类型的box数据，以下类似
        
        
    
       
       
  65. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
    
         
                 xmin = float(bbox.find(
         
         'xmin').text)
        
        
    
       
       
  66. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
    
         
                 ymax = float(bbox.find(
         
         'ymax').text)
        
        
    
       
       
  67. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
    
         
                 ymin = float(bbox.find(
         
         'ymin').text)
        
        
    
       
       
  68. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
    
         
                 width = xmax - xmin + 
         
         1                    
         
         # 计算width 和 height
        
        
    
       
       
  69. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
    
         
                 height = ymax - ymin + 
         
         1
        
        
    
       
       
  70. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
    
         
                 bboxs.append([xmin, ymin, width, height])  
         
         # 返回的box的形式是[xmin,ymin,wedth,height]
        
        
    
       
       
  71. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
     
        
        
    
       
       
  72. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
          
         
         for idx, object 
         
         in enumerate(root.iter(
         
         'object')):   
        
        
    
       
       
  73. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
    
         
                 id = object.find(
         
         'trackid').text 
         
         # 获取object的trackid,因为同一个video中可能存在多个需要跟踪的目标，加以区分
        
        
    
       
       
  74. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
    
         
                 class_name = object.find(
         
         'name').text  
         
         # 所属类别名称（VID中的30个大类）
        
        
    
       
       
  75. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
     
        
        
    
       
       
  76. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
    
         
                 track_save_dir = get_track_save_directory(save_dir, 
         
         'train', subdir, video)        
         
         # 获取存储路径
        
        
    
       
       
  77. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
    
         
                 mkdir_p(track_save_dir)
        
        
    
       
       
  78. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
    
         
                 savename = osp.join(track_save_dir, 
         
         '{}.{:02d}.crop.x.jpg'.format(filename, int(id)))    
        
        
    
       
       
  79. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
            
         
         if osp.isfile(savename): 
         
         continue  
         
         # skip existing images   # 文件存在的情况下无需存储
        
        
    
       
       
  80. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
     
        
        
    
       
       
  81. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
            
         
         if img 
         
         is 
         
         None:
        
        
    
       
       
  82. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
    
         
                   img = imread(img_file)   
         
         # 读取image文件
        
        
    
       
       
  83. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
     
        
        
    
       
       
  84. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
            
         
         # Get crop
        
        
    
       
       
  85. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
    
         
                 target_box = convert_bbox_format(Rectangle(*bboxs[idx]), 
         
         'center-based')   
         
         # box格式转换
        
        
    
       
       
  86. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
    
         
                 crop, _ = get_crops(img, target_box,
        
        
    
       
       
  87. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
    
         
                                     size_z=
         
         127, size_x=
         
         255,
        
        
    
       
       
  88. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
    
         
                                     context_amount=
         
         0.5, )
        
        
    
       
       
  89. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
     
        
        
    
       
       
  90. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
    
         
                 imwrite(savename, crop, [int(cv2.IMWRITE_JPEG_QUALITY), 
         
         90])   
         
         # 图片存储，质量为90
        
        
    
       
       
  91. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
     
        
        
    
       
       
  92. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
     
        
        
    
       
       
  93. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
    
         
         if __name__ == 
         
         '__main__':
        
        
    
       
       
  94. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
    
         
           vid_dir = osp.join(ROOT_DIR, 
         
         'data/ILSVRC2015')    
         
         # VID原始数据集存储的根目录，可以跟改为自己存储数据的绝对路径
        
        
    
       
       
  95. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
     
        
        
    
       
       
  96. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
      
         
         # Or, you could save the actual curated data to a disk with sufficient space
        
        
    
       
       
  97. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
      
         
         # then create a soft link in `data/ILSVRC2015-VID-Curation`
        
        
    
       
       
  98. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
    
         
           save_dir = 
         
         'data/ILSVRC2015-VID-Curation'   
         
         # 处理之后的数据存储的位置，可以修改为绝对路径
        
        
    
       
       
  99. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
     
        
        
    
       
       
  100. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
    
         
           pool = ThreadPool(processes=
         
         5)    
         
         # 开启5个线程加快处理速度
        
        
    
       
       
  101. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
     
        
        
    
       
       
  102. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
    
         
           one_work = 
         
         lambda a, b: process_split(vid_dir, save_dir, a, b)   
         
         # 执行函数，下面调用的时候每个会在每个线程中执行
        
        
    
       
       
  103. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
     
        
        
    
       
       
  104. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
    
         
           results = []
        
        
    
       
       
  105. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
    
         
           results.append(pool.apply_async(one_work, [
         
         'val', 
         
         ''])) 
         
         # 非阻塞方式，线程1调用one_work处理val数据集，下类似
        
        
    
       
       
  106. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
    
         
           results.append(pool.apply_async(one_work, [
         
         'train', 
         
         'ILSVRC2015_VID_train_0000'])) 
        
        
    
       
       
  107. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
    
         
           results.append(pool.apply_async(one_work, [
         
         'train', 
         
         'ILSVRC2015_VID_train_0001']))
        
        
    
       
       
  108. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
    
         
           results.append(pool.apply_async(one_work, [
         
         'train', 
         
         'ILSVRC2015_VID_train_0002']))
        
        
    
       
       
  109. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
    
         
           results.append(pool.apply_async(one_work, [
         
         'train', 
         
         'ILSVRC2015_VID_train_0003']))
        
        
    
       
       
  110. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
     
        
        
    
       
       
  111. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
    
         
           ans = [res.get() 
         
         for res 
         
         in results]       
         
         # 获取子线程结果，作用就是阻塞主线程，等待子线程执行完成

3.2 将训练数据保存为pickle格式

核心文件：scripts/build_VID2015_imdb.py

核心功能：将Data Curation处理后的训练数据存储为.pickle格式（train_imdb.pickle 和 validation_imdb.pickle）


     
     
  1. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
    
         
         #! /usr/bin/env python
        
        
    
       
       
  2. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
    
         
         # -*- coding: utf-8 -*-
        
        
    
       
       
  3. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
    
         
         #
        
        
    
       
       
  4. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
    
         
         # Copyright © 2017 bily     Huazhong University of Science and Technology
        
        
    
       
       
  5. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
    
         
         #
        
        
    
       
       
  6. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
    
         
         # Distributed under terms of the MIT license.
        
        
    
       
       
  7. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
     
        
        
    
       
       
  8. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
    
         
         """Save the paths of crops from the ImageNet VID 2015 dataset in pickle format"""
        
        
    
       
       
  9. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
    
         
         from __future__ 
         
         import absolute_import
        
        
    
       
       
  10. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
    
         
         from __future__ 
         
         import division
        
        
    
       
       
  11. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
    
         
         from __future__ 
         
         import print_function
        
        
    
       
       
  12. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
     
        
        
    
       
       
  13. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
    
         
         import glob
        
        
    
       
       
  14. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
    
         
         import os
        
        
    
       
       
  15. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
    
         
         import os.path 
         
         as osp
        
        
    
       
       
  16. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
    
         
         import pickle    
         
         # 导入pickle模块，将VID数据存储为pickle格式
        
        
    
       
       
  17. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
    
         
         import sys
        
        
    
       
       
  18. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
     
        
        
    
       
       
  19. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
    
         
         import numpy 
         
         as np
        
        
    
       
       
  20. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
    
         
         import tensorflow 
         
         as tf
        
        
    
       
       
  21. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
     
        
        
    
       
       
  22. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
    
         
         CURRENT_DIR = osp.dirname(__file__)
        
        
    
       
       
  23. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
    
         
         sys.path.append(osp.join(CURRENT_DIR, 
         
         '..'))   
         
         #  添加搜索路径
        
        
    
       
       
  24. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
     
        
        
    
       
       
  25. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
    
         
         from utils.misc_utils 
         
         import sort_nicely
        
        
    
       
       
  26. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
     
        
        
    
       
       
  27. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
     
        
        
    
       
       
  28. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
    
         
         class Config:     
         
         # 参数配置
        
        
    
       
       
  29. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
      
         
         ### Dataset
        
        
    
       
       
  30. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
      
         
         # directory where curated dataset is stored                           
        
        
    
       
       
  31. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
    
         
           dataset_dir = 
         
         '/home/ssd_datasets/ILSVRC2015_curated'   
         
         # 之前curated数据测存储路径，可使用绝对路径或相对路径
        
        
    
       
       
  32. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
    
         
           save_dir = 
         
         '/workspace/czx/Projects/SiamFC-TensorFlow/assets/'     
         
         # imdb文件存储路径   
        
        
    
       
       
  33. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
     
        
        
    
       
       
  34. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
      
         
         # percentage of all videos for validation
        
        
    
       
       
  35. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
    
         
           validation_ratio = 
         
         0.1     
         
         # validation所占的数据比例
        
        
    
       
       
  36. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
     
        
        
    
       
       
  37. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
     
        
        
    
       
       
  38. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
    
         
         class DataIter:
        
        
    
       
       
  39. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
      
         
         """Container for dataset of one iteration"""
        
        
    
       
       
  40. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
      
         
         pass
        
        
    
       
       
  41. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
     
        
        
    
       
       
  42. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
     
        
        
    
       
       
  43. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
    
         
         class Dataset:     
         
         # 数据集类
        
        
    
       
       
  44. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
      
         
         def __init__(self, config):    
         
         # 初始化参数设置
        
        
    
       
       
  45. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
    
         
             self.config = config
        
        
    
       
       
  46. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
     
        
        
    
       
       
  47. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
      
         
         def _get_unique_trackids(self, video_dir):    
         
         # 根据video_dir来获取特定的跟踪目标
        
        
    
       
       
  48. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
        
         
         """Get unique trackids within video_dir"""
        
        
    
       
       
  49. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
    
         
             x_image_paths = glob.glob(video_dir + 
         
         '/*.crop.x.jpg')   
         
         # 取得video_dir下所有crop图片存储的文件名
        
        
    
       
       
  50. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
    
         
             trackids = [os.path.basename(path).split(
         
         '.')[
         
         1] 
         
         for path 
         
         in x_image_paths]
         
         # 根据文件名获取对应trackid
        
        
    
       
       
  51. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
    
         
             unique_trackids = set(trackids)    
         
         # 因为每个视频snippet都可能有很多段小视频，每个小视频里面又会有多个跟踪的目标
        
        
    
       
       
  52. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
        
         
         return unique_trackids
        
        
    
       
       
  53. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
     
        
        
    
       
       
  54. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
      
         
         def dataset_iterator(self, video_dirs):     
         
         # 将所有的videos进行处理
        
        
    
       
       
  55. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
    
         
             video_num = len(video_dirs)               
         
         # videos的数量
        
        
    
       
       
  56. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
    
         
             iter_size = 
         
         150                           
         
         # 每次循环处理的视频个数
        
        
    
       
       
  57. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
    
         
             iter_num = int(np.ceil(video_num / float(iter_size)))        
        
        
    
       
       
  58. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
        
         
         for iter_ 
         
         in range(iter_num):                                                  
        
        
    
       
       
  59. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
    
         
               iter_start = iter_ * iter_size                     
        
        
    
       
       
  60. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
    
         
               iter_videos = video_dirs[iter_start: iter_start + iter_size]  
         
         # 每次处理的videos数量为150
        
        
    
       
       
  61. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
     
        
        
    
       
       
  62. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
    
         
               data_iter = DataIter()                              
        
        
    
       
       
  63. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
    
         
               num_videos = len(iter_videos)                                  
        
        
    
       
       
  64. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
    
         
               instance_videos = []
        
        
    
       
       
  65. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
          
         
         for index 
         
         in range(num_videos):
        
        
    
       
       
  66. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
    
         
                 print(
         
         'Processing {}/{}...'.format(iter_start + index, video_num))
        
        
    
       
       
  67. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
    
         
                 video_dir = iter_videos[index]    
         
         # 单个视频路径
        
        
    
       
       
  68. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
    
         
                 trackids = self._get_unique_trackids(video_dir)   
         
         # 该视频对应到有多少个target trackid
        
        
    
       
       
  69. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
     
        
        
    
       
       
  70. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
            
         
         for trackid 
         
         in trackids:
        
        
    
       
       
  71. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
    
         
                   instance_image_paths = glob.glob(video_dir + 
         
         '/*' + trackid + 
         
         '.crop.x.jpg') 
         
         #trackid所有图片的路径
        
        
    
       
       
  72. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
     
        
        
    
       
       
  73. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
              
         
         # sort image paths by frame number
        
        
    
       
       
  74. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
    
         
                   instance_image_paths = sort_nicely(instance_image_paths)     
         
         # 根据image number排序
        
        
    
       
       
  75. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
     
        
        
    
       
       
  76. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
              
         
         # get image absolute path   # 获得排序好的图片计算对应的图片的绝对路径
        
        
    
       
       
  77. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
    
         
                   instance_image_paths = [os.path.abspath(p) 
         
         for p 
         
         in instance_image_paths]    
        
        
    
       
       
  78. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
    
         
                   instance_videos.append(instance_image_paths)           
        
        
    
       
       
  79. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
    
         
               data_iter.num_videos = len(instance_videos)     
         
         # 150个视频里面trackid的数量，>=150
        
        
    
       
       
  80. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
    
         
               data_iter.instance_videos = instance_videos     
        
        
    
       
       
  81. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
          
         
         yield data_iter     
         
         # yield返回一个生成器
        
        
    
       
       
  82. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
     
        
        
    
       
       
  83. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
      
         
         def get_all_video_dirs(self):    
         
         # 获取VID数据集中所有videos的路径
        
        
    
       
       
  84. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
    
         
             ann_dir = os.path.join(self.config.dataset_dir, 
         
         'Data', 
         
         'VID')
        
        
    
       
       
  85. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
    
         
             all_video_dirs = []
        
        
    
       
       
  86. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
        
         
         # 根据之前预处理的训练数据存储的文件结构进行解析获取所有trackid的路径
        
        
    
       
       
  87. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
        
         
         # We have already combined all train and val videos in ILSVRC2015 and put them in the `train` directory.
        
        
    
       
       
  88. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
        
         
         # The file structure is like:
        
        
    
       
       
  89. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
        
         
         # train
        
        
    
       
       
  90. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
        
         
         #    |- a
        
        
    
       
       
  91. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
        
         
         #    |- b
        
        
    
       
       
  92. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
        
         
         #    |_ c
        
        
    
       
       
  93. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
        
         
         #       |- ILSVRC2015_train_00024001
        
        
    
       
       
  94. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
        
         
         #       |- ILSVRC2015_train_00024002
        
        
    
       
       
  95. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
        
         
         #       |_ ILSVRC2015_train_00024003
        
        
    
       
       
  96. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
        
         
         #               |- 000045.00.crop.x.jpg
        
        
    
       
       
  97. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
        
         
         #               |- 000046.00.crop.x.jpg
        
        
    
       
       
  98. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
        
         
         #               |- ...
        
        
    
       
       
  99. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
    
         
             train_dirs = os.listdir(os.path.join(ann_dir, 
         
         'train'))
        
        
    
       
       
  100. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
        
         
         for dir_ 
         
         in train_dirs:
        
        
    
       
       
  101. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
    
         
               train_sub_dir = os.path.join(ann_dir, 
         
         'train', dir_)
        
        
    
       
       
  102. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
    
         
               video_names = os.listdir(train_sub_dir)
        
        
    
       
       
  103. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
    
         
               train_video_dirs = [os.path.join(train_sub_dir, name) 
         
         for name 
         
         in video_names]
        
        
    
       
       
  104. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
    
         
               all_video_dirs = all_video_dirs + train_video_dirs
        
        
    
       
       
  105. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
     
        
        
    
       
       
  106. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
        
         
         return all_video_dirs                   
        
        
    
       
       
  107. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
     
        
        
    
       
       
  108. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
     
        
        
    
       
       
  109. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
    
         
         def main():
        
        
    
       
       
  110. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
      
         
         # Get the data.
        
        
    
       
       
  111. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
    
         
           config = Config()   
         
         # 加载参数设置
        
        
    
       
       
  112. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
    
         
           dataset = Dataset(config)    
         
         # dataset实例
        
        
    
       
       
  113. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
    
         
           all_video_dirs = dataset.get_all_video_dirs()    
         
         # 获取所有VID中videos的路径
        
        
    
       
       
  114. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
    
         
           num_validation = int(len(all_video_dirs) * config.validation_ratio)   
         
         # validation数据数量
        
        
    
       
       
  115. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
     
        
        
    
       
       
  116. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
      
         
         ### validation 数据
        
        
    
       
       
  117. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
    
         
           validation_dirs = all_video_dirs[:num_validation]
        
        
    
       
       
  118. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
    
         
           validation_imdb = dict()
        
        
    
       
       
  119. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
    
         
           validation_imdb[
         
         'videos'] = []
        
        
    
       
       
  120. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
      
         
         for i, data_iter 
         
         in enumerate(dataset.dataset_iterator(validation_dirs)):  
        
        
    
       
       
  121. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
    
         
             validation_imdb[
         
         'videos'] += data_iter.instance_videos                                    
        
        
    
       
       
  122. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
     
        
        
    
       
       
  123. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
    
         
           validation_imdb[
         
         'n_videos'] = len(validation_imdb[
         
         'videos'])   
         
         # 视频数量                           
        
        
    
       
       
  124. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
    
         
           validation_imdb[
         
         'image_shape'] = (
         
         255, 
         
         255, 
         
         3)    
         
         # 图片大小
        
        
    
       
       
  125. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
     
        
        
    
       
       
  126. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
      
         
         ### train 数据
        
        
    
       
       
  127. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
    
         
           train_dirs = all_video_dirs[num_validation:]
        
        
    
       
       
  128. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
    
         
           train_imdb = dict()
        
        
    
       
       
  129. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
    
         
           train_imdb[
         
         'videos'] = []
        
        
    
       
       
  130. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
      
         
         for i, data_iter 
         
         in enumerate(dataset.dataset_iterator(train_dirs)):
        
        
    
       
       
  131. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
    
         
             train_imdb[
         
         'videos'] += data_iter.instance_videos
        
        
    
       
       
  132. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
    
         
           train_imdb[
         
         'n_videos'] = len(train_imdb[
         
         'videos'])
        
        
    
       
       
  133. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
    
         
           train_imdb[
         
         'image_shape'] = (
         
         255, 
         
         255, 
         
         3)
        
        
    
       
       
  134. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
     
        
        
    
       
       
  135. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
      
         
         if 
         
         not tf.gfile.IsDirectory(config.save_dir):    
         
         # imdb数据存储路径
        
        
    
       
       
  136. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
    
         
             tf.logging.info(
         
         'Creating training directory: %s', config.save_dir)
        
        
    
       
       
  137. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
    
         
             tf.gfile.MakeDirs(config.save_dir)
        
        
    
       
       
  138. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
     
        
        
    
       
       
  139. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
      
         
         with open(os.path.join(config.save_dir, 
         
         'validation_imdb.pickle'), 
         
         'wb') 
         
         as f:
        
        
    
       
       
  140. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
    
         
             pickle.dump(validation_imdb, f)
        
        
    
       
       
  141. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
      
         
         with open(os.path.join(config.save_dir, 
         
         'train_imdb.pickle'), 
         
         'wb') 
         
         as f:
        
        
    
       
       
  142. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
    
         
             pickle.dump(train_imdb, f)
        
        
    
       
       
  143. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
     
        
        
    
       
       
  144. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
     
        
        
    
       
       
  145. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
    
         
         if __name__ == 
         
         '__main__':
        
        
    
       
       
  146. 
       
       
    
        
        
    
       
       
    
       
       
    
        
        
    
         
           main()

4： 小结

1：核心介绍了VID2015数据集的结构是怎么样的，以及进行SiameseFC训练之前需要对该数据集如何处理。

2：这部分数据处理因为很早之前就已经处理好了，这里只贴一下一个样例吧。

原始图片样例：/Data/VID/train/ILSVRC2015_VID_train_0000/ILSVRC2015_train_00005004/000000.jpeg

原始的图片大小：1280*256。（下图是原图片截图）


Data Curation之后保存的图片：255*255，这就是训练过程中加载的search image。（也是截图）


这里还贴一个训练过程中crop出来的一个127*127的examplar吧。（还是截图）


3：训练数据VID2015的准备工作到这基本就做好了，接下来该聊聊如何构建模型了。要是觉得这份代码还不错，就顺手点个star吧，哈哈。

汽车行业小硕妹子
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
PySOT单目标跟踪训练、测试、验证全流程（全网最详细，持续更新，建议收藏！）
qq_29136815的博客
04-07 4622
使用Anaconda安装好pytorch环境后，右下角解释器切换为自己的环境，然后打开terminal，输入pip install -r requirements.txt -i https:pypi.douban.com/simple（使用豆瓣源） 批量安装所需环境。链接：https://pan.baidu.com/s/1kvEDkNfzgLW7j5PfefC_tA?可以用git获取，也可以直接下载.zip文件，然后解压到本地，在PyCharm中打开。
ILSVRC-Vid-2015-Video-Detection-:ILSVRC Vid 2015视频检测笔记本
04-10
ILSVRC-Vid-2015-视频检测- ILSVRC Vid 2015视频检测笔记本。
ILSVRC2015_VID数据集说明
du的博客
11-20 8579
参考：https://blog.csdn.net/weixin_43292354/article/details/100155303 数据主页：http://bvisionweb1.cs.unc.edu/ilsvrc2015/download-videos-3j16.php#vid 数据下载：http://bvisionweb1.cs.unc.edu/ilsvrc2015/ILSVRC2015_VID.tar.gz
ImageNet VID数据集 / ILSVRC 2015-VID数据集
qq_40535862的博客
05-18 5729
ImageNet VID数据集 / ILSVRC 2015-VID数据集介绍： 研究方向为视频目标检测，需要使用视频目标检测数据集，发现关于介绍ImageNet VID数据集的博客不多，就自己记录一下 类别 该数据集一共有30个类别，是ImageNet DET数据集200个类别的子集。ImageNet VID数据集一共有3862个视频片段用于训练，555个视频片段用于验证，937个视频片段用于测试。 30个类别为： n02691156 1 airplane n02419796 2 antelope n021
数据融合matlab代码-Person_RE-ID:Person_RE-ID
05-22
数据融合matlab代码两流CNN-RNN网络，带有用于Person re-ID的专心池 概括： 我们通过使用两个流来执行视频重新ID，每个流都是基于暹罗语的。 RGB和光流分别作为输入，以分别学习空间和时间信息。 我们在我们的基础...
二抽取代码MATLAB-VID:VID至尊代码
05-26
【标题】"二抽取代码MATLAB-VID:VID至尊代码" 涉及的主要知识点是图像处理中的视频帧间差分（Interframe Difference）技术，通常用于运动目标检测。在MATLAB环境中，这一技术被广泛应用于计算机视觉和视频分析领域。...
matlab集成c代码-img2vid:img2vid
05-22
Matlab集成的c代码 img2vid 一个轻量级的matlab库，用于将视频图像制作成视频 它包含用于在出版物中生成视频的源代码： 如果您发现img2vid有用，请引用我们的论文。 v0.1 管道 将现有图像（用相机或PMT捕获）加载到...
DukeMTMC-VideoReID:DukeMTMC-VideoReID数据集的说明和基线代码
05-09
数据集由用于训练的702个身份，用于测试的702个身份和作为干扰项的408个身份组成。 总共有2,196个用于培训的视频和2,636个用于测试的视频。 每个视频包含每12帧采样一次的人物图像。 在测试过程中，将使用每个ID的...
DL实战(2)：SiamFC - TensorFlow配置
樛木
06-11 4607
git链接：https://github.com/torrvision/siamfc-tf管理员身份运行Anaconda Prompt（我的是py36版本）安装virtualenv，其用来为一个应用创建一套“隔离”的Python运行环境。pip install virtualenv cd 新项目目录 E: cd E:\pyProject用命令virtualenv创建一个独立的Python运行环境，...
硬件厂商VID大全
10-31
一般硬件对应有VID, 如果需要获取厂商名字就需要查这张表
制作自己的ILSVRC2015 VID数据集的一些脚本以及流程
ajsdfjj的博客
01-13 3017
前言：刚开始做视频目标检测的时候需要把我们实验室的医疗数据制作成ILSVRC2015 VID这样格式的数据，但是在网上没怎么找到攻略，故把自己的一些经验记录下来。 1、json转xml：由labelme这个软件标注出来的数据集一般都是json格式的，需要把json标注格式转化成xml格式。 import os from typing import List, Any import numpy as np import codecs import json from glob
USB设备Vid和Pid对应设备查询
时有限
03-02 8862
查询地址参见：linux-usb-org 地址格式如下，vid和pid分别为对应的含义。
ILSVRC2015_VID数据集详解
lighten-1996的博客
08-30 1万+
数据集下载地址：http://bvisionweb1.cs.unc.edu/ilsvrc2015/ILSVRC2015_VID.tar.gz 总说： 数据集包括3862 snippets用于训练，555 snippets用于验证，937 snippets用于测试。 每个snippet包括56~458帧图像不等。 视频中的目标检测，类似目标检测任务的风格。该任务有30个基本类别，是目标检测任务200...
多模态融合——运动视频数据集
weixin_42371645的博客
05-31 301
多模态数据集
SiamFC：基于全卷积孪生网络的目标跟踪算法
热门推荐
xiaoou的博客
12-09 3万+
Abstract 本论文提出一种新的全卷积孪生网络作为基本的跟踪算法，这个网络在ILSVRC15的目标跟踪视频数据集上进行端到端的训练。我们的跟踪器在帧率上超过了实时性要求，尽管它非常简单，但在多个benchmark上达到最优的性能。 1. Introduction 最近很多研究通过使用预训练模型来解决上述问题。这些方法中，要么使用网络内部某一层作为特征的shallow方法（如相关滤波）；要...
ImageNet大规模视觉识别竞赛 ILSVRC 2015-VID数据集
沈春旭的博客
07-11 3万+
数据主页：http://bvisionweb1.cs.unc.edu/ilsvrc2015/download-videos-3j16.php#vidObject detection from video 视频中的目标检测，简称VID。目前官方已经完全开放了数据集包括3862 snnipets用于训练，555 snippets用于验证， 937 snippets用于测试。数据下载地址：http://...
目标跟踪领域的数据集(Lasot，Got10k，TrackingNet, ImageNet-VID(ILSVRC 2015-VID)）有多大
页页读
06-14 8385
目标跟踪领域的数据集（Lasot，Got10k，TrackingNet）有多大 Lasot 一共有56个压缩包，共192.3GB. 压缩包中是啥呢？ 以airplane为例，它是这样的： 再往里是这样的： 再往里img中是这样的： groundtruth.txt是这样的： Got10k Got10k link address 可以看到Full data一个是66GB. 文件结构是这样的： TrackingNet TrackingNet google云盘 共有13个压缩包，Train每个基本
ILSVRC2015_VID数据集名称
最新发布
weixin_44487904的博客
07-12 167
n02691156 1 airplane n02419796 2 antelope n02131653 3 bear n02834778 4 bicycle n01503061 5 bird n02924116 6 bus n02958343 7 car n02402425 8 cattle n02084071 9 dog n02121808 10 domestic_cat n02503517 11 elephant n02118333 12 fox n02510455 13 giant_panda n02
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值