当前位置:   article > 正文

VOC和COCO数据集_voc数据集和coco数据集区别

voc数据集和coco数据集区别

一.Pascal VOC(Pascal Visual Object Classes)

Pascal VOC网址:http://host.robots.ox.ac.uk/pascal/VOC/ 
查看各位大牛算法的排名的Leaderboards:http://host.robots.ox.ac.uk:8080/leaderboard/main_bootstrap.php 
训练/验证数据集下载(2G):host.robots.ox.ac.uk/pascal/VOC/voc2012/VOCtrainval_11-May-2012.tar

VOC数据集是目标检测经常用的一个数据集,从05年到12年都会举办比赛(比赛有task: Classification 、Detection(将图片中所有的目标用bounding box框出来) 、 Segmentation(将图片中所有的目标分割出来)、Person Layout)
VOC2007:中包含9963张标注过的图片, 由train/val/test三部分组成, 共标注出24,640个物体。 VOC2007的test数据label已经公布, 之后的没有公布(只有图片,没有label)。

VOC2012:对于检测任务,VOC2012的trainval/test包含08-11年的所有对应图片。 trainval有11540张图片共27450个物体。 对于分割任务, VOC2012的trainval包含07-11年的所有对应图片, test只包含08-11。trainval有 2913张图片共6929个物体。

这些物体一共分为20类:

  • Person: person 
  • Animal: bird, cat, cow, dog, horse, sheep 
  • Vehicle: aeroplane, bicycle, boat, bus, car, motorbike, train 
  • Indoor: bottle, chair, dining table, potted plant, sofa, tv/monitor
     

数据集下载后解压得到一个名为VOCdevkit的文件夹,该文件夹结构如下:

.
└── VOCdevkit     #根目录
    └── VOC2012   #不同年份的数据集,这里只下载了2012的,还有2007等其它年份的
        ├── Annotations        #存放xml文件,与JPEGImages中的图片一一对应,解释图片的内容等等
        ├── ImageSets          #该目录下存放的都是txt文件,txt文件中每一行包含一个图片的名称,末尾会加上±1表示正负样本
        │   ├── Action
        │   ├── Layout
        │   ├── Main
        │   └── Segmentation
        ├── JPEGImages         #存放源图片
        ├── SegmentationClass  #存放的是图片,分割后的效果,见下文的例子
        └── SegmentationObject #存放的是图片,分割后的效果,见下文的例子

  • Annotation文件夹存放的是xml文件,该文件是对图片的解释,每张图片都对于一个同名的xml文件。 
  • ImageSets文件夹存放的是txt文件,这些txt将数据集的图片分成了各种集合。如Main下的train.txt中记录的是用于训练的图片集合 
  • JPEGImages文件夹存放的是数据集的原图片 
  • SegmentationClass以及SegmentationObject文件夹存放的都是图片,且都是图像分割结果图

JEPGImages文件夹

该文件夹存放的是数据集的所有源图片,内容如下: 

                      

Annotation文件夹 

Annotation文件夹的内容如下: 

                         

其中xml主要介绍了对应图片的基本信息,如来自那个文件夹、文件名、来源、图像尺寸以及图像中包含哪些目标以及目标的信息等等,内容如下:

  1. <annotation>
  2. <folder>VOC2007</folder>
  3. <filename>000005.jpg</filename>#文件名
  4. <source>#文件来源
  5. <database>The VOC2007 Database</database>
  6. <annotation>PASCAL VOC2007</annotation>
  7. <image>flickr</image>
  8. <flickrid>325991873</flickrid>
  9. </source>
  10. <owner>
  11. <flickrid>archintent louisville</flickrid>
  12. <name>?</name>
  13. </owner>
  14. <size>#文件尺寸,包括长、宽、通道数
  15. <width>500</width>
  16. <height>375</height>
  17. <depth>3</depth>
  18. </size>
  19. <segmented>0</segmented>#是否用于分割
  20. <object>#检测目标
  21. <name>chair</name>#目标类别
  22. <pose>Rear</pose>#摄像头角度
  23. <truncated>0</truncated>#是否被截断,0表示完整
  24. <difficult>0</difficult>#目标是否难以识别,0表示容易识别
  25. <bndbox>#bounding-box
  26. <xmin>263</xmin>
  27. <ymin>211</ymin>
  28. <xmax>324</xmax>
  29. <ymax>339</ymax>
  30. </bndbox>
  31. </object>
  32. <object>#检测到的多个物体, 可以看到上图中,图片000005中有多个椅子
  33. <name>chair</name>
  34. <pose>Unspecified</pose>
  35. <truncated>0</truncated>
  36. <difficult>0</difficult>
  37. <bndbox>
  38. <xmin>165</xmin>
  39. <ymin>264</ymin>
  40. <xmax>253</xmax>
  41. <ymax>372</ymax>
  42. </bndbox>
  43. </object>
  44. <object>#检测到的多个物体
  45. <name>chair</name>
  46. <pose>Unspecified</pose>
  47. <truncated>1</truncated>
  48. <difficult>1</difficult>
  49. <bndbox>
  50. <xmin>5</xmin>
  51. <ymin>244</ymin>
  52. <xmax>67</xmax>
  53. <ymax>374</ymax>
  54. </bndbox>
  55. </object>
  56. <object>
  57. <name>chair</name>
  58. <pose>Unspecified</pose>
  59. <truncated>0</truncated>
  60. <difficult>0</difficult>
  61. <bndbox>
  62. <xmin>241</xmin>
  63. <ymin>194</ymin>
  64. <xmax>295</xmax>
  65. <ymax>299</ymax>
  66. </bndbox>
  67. </object>
  68. <object>#检测到的多个物体
  69. <name>chair</name>
  70. <pose>Unspecified</pose>
  71. <truncated>1</truncated>
  72. <difficult>1</difficult>
  73. <bndbox>
  74. <xmin>277</xmin>
  75. <ymin>186</ymin>
  76. <xmax>312</xmax>
  77. <ymax>220</ymax>
  78. </bndbox>
  79. </object>
  80. </annotation>

对应图片为:

                                   

 ImageSets文件夹

ImageSets包含如下四个子文件夹: 

                          

  • Action下存放的是人的动作(例如running、jumping等等,这也是VOC challenge的一部分)
  • Layout下存放的是具有人体部位的数据(人的head、hand、feet等等,这也是VOC challenge的一部分)
  • Main下存放的是图像物体识别的数据,总共分为20类。
  • Segmentation下存放的是可用于分割的数据。

 然后我们主要关注于main文件夹。里面放了20个类的train、val、trainval的txt。

                                   

  • _train中存放的是训练使用的数据,每一个class的train数据都有5717个。
  • _val中存放的是验证结果使用的数据,每一个class的val数据都有5823个。
  • _trainval将上面两个进行了合并,每一个class有11540个。

                                                  

上图中前面代表图片编号,后面-1代表负样本,1代表正样本。

 SegmentationClass文件夹

这里面包含了2913张图片,每一张图片都对应JPEGImages里面的相应编号的图片。这里面的图片的像素颜色共有20种,对应20类物体。比如所有飞机都会被标为红色。

                                

SegmentationObject文件夹 

这里面同样包含了2913张图片,图片编号都与Class里面的图片编号相同。这里面的图片和Class里面图片的区别在于,这是针对Object的。在Class里面,一张图片里如果有多架飞机,那么会全部标注为红色。而在Object里面,同一张图片里面的飞机会被不同颜色标注出来。

                                   

 

二.Microsoft COCO(Common Objects in Context)

COCO的 全称是Common Objects in COntext,是微软团队提供的一个可以用来进行图像识别的数据集。MS COCO数据集中的图像分为训练、验证和测试集。COCO通过在Flickr上搜索80个对象类别和各种场景类型来收集图像,其使用了亚马逊的Mechanical Turk(AMT)。

COCO数据集是微软团队获取的一个可以用来图像recognition+segmentation+captioning 数据集,其官方说明网址:http://mscoco.org/

该数据集主要有的特点如下:(1)Object segmentation(2)Recognition in Context(3)Multiple objects per image(4)More than 300,000 images(5)More than 2 Million instances(6)80 object categories(7)5 captions per image(8)Keypoints on 100,000 people

该数据集主要解决3个问题:目标检测,目标之间的上下文关系,目标的2维上的精确定位。数据集的对比示意图:

                            

 

COCO的2019挑战赛有如下内容COCO 2019 DetectionKeypointPanoptic, and DensePose Challenges。

COCO通过大量使用Amazon Mechanical Turk来收集数据。COCO数据集现在有3种标注类型:object instances(目标实例), object keypoints(目标上的关键点), 和image captions(看图说话),使用JSON文件存储。比如下面就是Gemfield下载的COCO 2017年训练集中的标注文件:

                    

可以看到其中有上面所述的三种类型,每种类型又包含了训练和验证,所以共6个JSON文件。

基本的JSON结构体类型

object instances(目标实例)、object keypoints(目标上的关键点)、image captions(看图说话)这3种类型共享这些基本类型:info、image、license。

而annotation类型则呈现出了多态:

  1. {
  2. "info": info,
  3. "licenses": [license],
  4. "images": [image],
  5. "annotations": [annotation],
  6. }
  7. info{
  8. "year": int,
  9. "version": str,
  10. "description": str,
  11. "contributor": str,
  12. "url": str,
  13. "date_created": datetime,
  14. }
  15. license{
  16. "id": int,
  17. "name": str,
  18. "url": str,
  19. }
  20. image{
  21. "id": int,
  22. "width": int,
  23. "height": int,
  24. "file_name": str,
  25. "license": int,
  26. "flickr_url": str,
  27. "coco_url": str,
  28. "date_captured": datetime,
  29. }

1,info类型,比如一个info类型的实例:

  1. "info":{
  2. "description":"This is stable 1.0 version of the 2014 MS COCO dataset.",
  3. "url":"http:\/\/mscoco.org",
  4. "version":"1.0","year":2014,
  5. "contributor":"Microsoft COCO group",
  6. "date_created":"2015-01-27 09:11:52.357475"
  7. },

2,Images是包含多个image实例的数组,对于一个image类型的实例:

  1. {
  2. "license":3,
  3. "file_name":"COCO_val2014_000000391895.jpg",
  4. "coco_url":"http:\/\/mscoco.org\/images\/391895",
  5. "height":360,"width":640,"date_captured":"2013-11-14 11:18:45",
  6. "flickr_url":"http:\/\/farm9.staticflickr.com\/8186\/8119368305_4e622c8349_z.jpg",
  7. "id":391895
  8. },

3,licenses是包含多个license实例的数组,对于一个license类型的实例:

  1. {
  2. "url":"http:\/\/creativecommons.org\/licenses\/by-nc-sa\/2.0\/",
  3. "id":1,
  4. "name":"Attribution-NonCommercial-ShareAlike License"
  5. },

Object Instance 类型的标注格式

1,整体JSON文件格式

比如上图中的instances_train2017.json、instances_val2017.json这两个文件就是这种格式。

Object Instance这种格式的文件从头至尾按照顺序分为以下段落:

  1. {
  2. "info": info,
  3. "licenses": [license],
  4. "images": [image],
  5. "annotations": [annotation],
  6. "categories": [category]
  7. }

是的,你打开这两个文件,虽然内容很多,但从文件开始到结尾按照顺序就是这5段。其中,info、licenses、images这三个结构体/类型 在上一节中已经说了,在不同的JSON文件中这三个类型是一样的,定义是共享的。不共享的是annotation和category这两种结构体,他们在不同类型的JSON文件中是不一样的。

images数组元素的数量等同于划入训练集(或者测试集)的图片的数量;

annotations数组元素的数量等同于训练集(或者测试集)中bounding box的数量;

categories数组元素的数量为80(2017年);

  1. >>> ann_train_file='annotations/instances_train2017.json'
  2. >>> coco_train = COCO(ann_train_file)
  3. loading annotations into memory...
  4. Done (t=19.30s)
  5. creating index...
  6. index created!
  7. >>> len(coco_train.dataset['categories'])
  8. 80
  9. >>> len(coco_train.dataset['images'])
  10. 118287
  11. >>> len(coco_train.dataset['annotations'])
  12. 860001
  13. >>>

2,annotations字段

annotations字段是包含多个annotation实例的一个数组,annotation类型本身又包含了一系列的字段,如这个目标的category id和segmentation mask。segmentation格式取决于这个实例是一个单个的对象(即iscrowd=0,将使用polygons格式)还是一组对象(即iscrowd=1,将使用RLE格式)。如下所示:

  1. annotation{
  2. "id": int,
  3. "image_id": int,
  4. "category_id": int,
  5. "segmentation": RLE or [polygon],
  6. "area": float,
  7. "bbox": [x,y,width,height],
  8. "iscrowd": 0 or 1,
  9. }

注意,单个的对象(iscrowd=0)可能需要多个polygon来表示,比如这个对象在图像中被挡住了。而iscrowd=1时(将标注一组对象,比如一群人)的segmentation使用的就是RLE格式。

注意啊,只要是iscrowd=0那么segmentation就是polygon格式;只要iscrowd=1那么segmentation就是RLE格式。另外,每个对象(不管是iscrowd=0还是iscrowd=1)都会有一个矩形框bbox ,矩形框左上角的坐标和矩形框的长宽会以数组的形式提供,数组第一个元素就是左上角的横坐标值。

area是area of encoded masks,是标注区域的面积。如果是矩形框,那就是高乘宽;如果是polygon或者RLE,那就复杂点。

最后,annotation结构中的categories字段存储的是当前对象所属的category的id,以及所属的supercategory的name。

下面是从instances_val2017.json文件中摘出的一个annotation的实例,这里的segmentation就是polygon格式:

  1. {
  2. "segmentation": [[510.66,423.01,511.72,420.03,510.45......]],
  3. "area": 702.1057499999998,
  4. "iscrowd": 0,
  5. "image_id": 289343,
  6. "bbox": [473.07,395.93,38.65,28.67],
  7. "category_id": 18,
  8. "id": 1768
  9. },

polygon格式比较简单,这些数按照相邻的顺序两两组成一个点的xy坐标,如果有n个数(必定是偶数),那么就是n/2个点坐标。下面就是一段解析polygon格式的segmentation并且显示多边形的示例代码:

  1. import numpy as np
  2. import matplotlib.pyplot as plt
  3. import matplotlib
  4. from matplotlib.patches import Polygon
  5. from matplotlib.collections import PatchCollection
  6. fig, ax = plt.subplots()
  7. polygons = []
  8. num_sides = 100
  9. gemfield_polygons = [[125.12, 539.69, 140.94, 522.43......]]
  10. gemfield_polygon = gemfield_polygons[0]
  11. max_value = max(gemfield_polygon) * 1.3
  12. gemfield_polygon = [i * 1.0/max_value for i in gemfield_polygon]
  13. poly = np.array(gemfield_polygon).reshape((int(len(gemfield_polygon)/2), 2))
  14. polygons.append(Polygon(poly,True))
  15. p = PatchCollection(polygons, cmap=matplotlib.cm.jet, alpha=0.4)
  16. colors = 100*np.random.rand(1)
  17. p.set_array(np.array(colors))
  18. ax.add_collection(p)
  19. plt.show()

如果iscrowd=1,那么segmentation就是RLE格式(segmentation字段会含有counts和size数组),在json文件中gemfield挑出一个这样的例子,如下所示:

  1. segmentation :
  2. {
  3. u'counts': [272, 2, 4, 4, 4, 4, 2, 9, 1, 2, 16, 43, 143, 24......],
  4. u'size': [240, 320]
  5. }

COCO数据集的RLE都是uncompressed RLE格式(与之相对的是compact RLE)。 RLE所占字节的大小和边界上的像素数量是正相关的。RLE格式带来的好处就是当基于RLE去计算目标区域的面积以及两个目标之间的unoin和intersection时会非常有效率。 上面的segmentation中的counts数组和size数组共同组成了这幅图片中的分割 mask。其中size是这幅图片的宽高,然后在这幅图像中,每一个像素点要么在被分割(标注)的目标区域中,要么在背景中。很明显这是一个bool量:如果该像素在目标区域中为true那么在背景中就是False;如果该像素在目标区域中为1那么在背景中就是0。对于一个240x320的图片来说,一共有76800个像素点,根据每一个像素点在不在目标区域中,我们就有了76800个bit,比如像这样(随便写的例子,和上文的数组没关系):00000111100111110...;但是这样写很明显浪费空间,我们直接写上0或者1的个数不就行了嘛(Run-length encoding),于是就成了54251...,这就是上文中的counts数组,这里相邻的数字代表了不同的意义,是0和1的相互嵌套,即为记录连续的0和1的个数,当出现0和1的相互转换时,将当前的0或者1的个数记录在数组当中。下面这个python代码片段直观的显示了这些bit:

  1. rle = [272, 2, 4, 4, 4, 4, 2, 9, 1, 2, 16, 43, 143, 24, 5, 8......]
  2. assert sum(rle) == 240*320

也可以使用下面的代码将这个rle数组表示的分割区域画出来:

  1. import numpy as np
  2. import matplotlib.pyplot as plt
  3. rle = [272, 2, 4, 4, 4, 4, 2, 9, 1, 2, 16, 43, 143, 24, 5, 8......]
  4. assert sum(rle) == 240*320
  5. M = np.zeros(240*320)
  6. N = len(rle)
  7. n = 0
  8. val = 1
  9. for pos in range(N):
  10. val = not val
  11. for c in range(rle[pos]):
  12. M[n] = val
  13. n += 1
  14. GEMFIELD = M.reshape(([240, 320]), order='F')
  15. plt.imshow(GEMFIELD)
  16. plt.show()

3,categories字段

categories是一个包含多个category实例的数组,而category结构体描述如下:

  1. {
  2. "id": int,
  3. "name": str,
  4. "supercategory": str,
  5. }

从instances_val2017.json文件中摘出的2个category实例如下所示:

  1. {
  2. "supercategory": "person",
  3. "id": 1,
  4. "name": "person"
  5. },
  6. {
  7. "supercategory": "vehicle",
  8. "id": 2,
  9. "name": "bicycle"
  10. },

至2017年的时候,一共有80个category。

Object Keypoint 类型的标注格式

1,整体JSON文件格式

比如上图中的person_keypoints_train2017.json、person_keypoints_val2017.json这两个文件就是这种格式。

Object Keypoint这种格式的文件从头至尾按照顺序分为以下段落,看起来和Object Instance一样啊:

  1. {
  2. "info": info,
  3. "licenses": [license],
  4. "images": [image],
  5. "annotations": [annotation],
  6. "categories": [category]
  7. }

是的,你打开这两个文件,虽然内容很多,但从文件开始到结尾按照顺序就是这5段。其中,info、licenses、images这三个结构体/类型 在第一节中已经说了,在不同的JSON文件中这三个类型是一样的,定义是共享的。不共享的是annotation和category这两种结构体,他们在不同类型的JSON文件中是不一样的。

images数组元素数量是划入训练集(测试集)的图片的数量;

annotations是bounding box的数量,在这里只有人这个类别的bounding box;

categories数组元素的数量为1,只有一个:person(2017年);

2,annotations字段

这个类型中的annotation结构体包含了Object Instance中annotation结构体的所有字段,再加上2个额外的字段。

新增的keypoints是一个长度为3*k的数组,其中k是category中keypoints的总数量。每一个keypoint是一个长度为3的数组,第一和第二个元素分别是x和y坐标值,第三个元素是个标志位v,v为0时表示这个关键点没有标注(这种情况下x=y=v=0),v为1时表示这个关键点标注了但是不可见(被遮挡了),v为2时表示这个关键点标注了同时也可见。

num_keypoints表示这个目标上被标注的关键点的数量(v>0),比较小的目标上可能就无法标注关键点。

  1. annotation{
  2. "keypoints": [x1,y1,v1,...],
  3. "num_keypoints": int,
  4. "id": int,
  5. "image_id": int,
  6. "category_id": int,
  7. "segmentation": RLE or [polygon],
  8. "area": float,
  9. "bbox": [x,y,width,height],
  10. "iscrowd": 0 or 1,
  11. }

从person_keypoints_val2017.json文件中摘出一个annotation的实例如下:

  1. {
  2. "segmentation": [[125.12,539.69,140.94,522.43...]],
  3. "num_keypoints": 10,
  4. "area": 47803.27955,
  5. "iscrowd": 0,
  6. "keypoints": [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,142,309,1,177,320,2,191,398...],
  7. "image_id": 425226,"bbox": [73.35,206.02,300.58,372.5],"category_id": 1,
  8. "id": 183126
  9. },

3,categories字段

最后,对于每一个category结构体,相比Object Instance中的category新增了2个额外的字段,keypoints是一个长度为k的数组,包含了每个关键点的名字;skeleton定义了各个关键点之间的连接性(比如人的左手腕和左肘就是连接的,但是左手腕和右手腕就不是)。目前,COCO的keypoints只标注了person category (分类为人)。

定义如下:

  1. {
  2. "id": int,
  3. "name": str,
  4. "supercategory": str,
  5. "keypoints": [str],
  6. "skeleton": [edge]
  7. }

从person_keypoints_val2017.json文件中摘出一个category的实例如下:

  1. {
  2. "supercategory": "person",
  3. "id": 1,
  4. "name": "person",
  5. "keypoints": ["nose","left_eye","right_eye","left_ear","right_ear","left_shoulder","right_shoulder","left_elbow","right_elbow","left_wrist","right_wrist","left_hip","right_hip","left_knee","right_knee","left_ankle","right_ankle"],
  6. "skeleton": [[16,14],[14,12],[17,15],[15,13],[12,13],[6,12],[7,13],[6,7],[6,8],[7,9],[8,10],[9,11],[2,3],[1,2],[1,3],[2,4],[3,5],[4,6],[5,7]]
  7. }

Image Caption的标注格式

1,整体JSON文件格式

比如上图中的captions_train2017.json、captions_val2017.json这两个文件就是这种格式。

Image Caption这种格式的文件从头至尾按照顺序分为以下段落,看起来和Object Instance一样,不过没有最后的categories字段:

  1. {
  2. "info": info,
  3. "licenses": [license],
  4. "images": [image],
  5. "annotations": [annotation]
  6. }

是的,你打开这两个文件,虽然内容很多,但从文件开始到结尾按照顺序就是这4段。其中,info、licenses、images这三个结构体/类型 在第一节中已经说了,在不同的JSON文件中这三个类型是一样的,定义是共享的。不共享的是annotations这种结构体,它在不同类型的JSON文件中是不一样的。

images数组的元素数量等于划入训练集(或者测试集)的图片的数量;

annotations的数量要多于图片的数量,这是因为一个图片可以有多个场景描述;

2,annotations字段

这个类型中的annotation用来存储描述图片的语句。每个语句描述了对应图片的内容,而每个图片至少有5个描述语句(有的图片更多)。annotation定义如下:

  1. annotation{
  2. "id": int,
  3. "image_id": int,
  4. "caption": str
  5. }

从captions_val2017.json中摘取的一个annotation实例如下:

  1. {
  2. "image_id": 179765,
  3. "id": 38,"caption": "A black Honda motorcycle parked in front of a garage."
  4. }

 

声明:本文内容由网友自发贡献,不代表【wpsshop博客】立场,版权归原作者所有,本站不承担相应法律责任。如您发现有侵权的内容,请联系我们。转载请注明出处:https://www.wpsshop.cn/w/天景科技苑/article/detail/780641
推荐阅读
相关标签
  

闽ICP备14008679号