Huawei_Technology
/
mindspore
Not watched
1
0
Fork 0
Code
Releases 13 Wiki evaluate Activity
Issues 0 Pull Requests 0 Datasets Model Cloudbrain HPC
You can not select more than 25 topics Topics must start with a chinese character,a letter or number, can include dashes ('-') and can be up to 35 characters long.
Tree: e497117b74
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'e497117b74'
${ noResults }
mindspore/tests/ut/python/dataset/test_datasets_coco.py

288 lines
12 kB
Raw Blame History 

  1. # Copyright 2020 Huawei Technologies Co., Ltd

  2. #

  3. # Licensed under the Apache License, Version 2.0 (the "License");

  4. # you may not use this file except in compliance with the License.

  5. # You may obtain a copy of the License at

  6. #

  7. # http://www.apache.org/licenses/LICENSE-2.0

  8. #

  9. # Unless required by applicable law or agreed to in writing, software

  10. # distributed under the License is distributed on an "AS IS" BASIS,

  11. # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  12. # See the License for the specific language governing permissions and

  13. # limitations under the License.

  14. # ==============================================================================

  15. import numpy as np

  16. import mindspore.dataset as ds

  17. import mindspore.dataset.transforms.vision.c_transforms as vision

  18. 

  19. DATA_DIR = "../data/dataset/testCOCO/train/"

  20. DATA_DIR_2 = "../data/dataset/testCOCO/train"

  21. ANNOTATION_FILE = "../data/dataset/testCOCO/annotations/train.json"

  22. KEYPOINT_FILE = "../data/dataset/testCOCO/annotations/key_point.json"

  23. PANOPTIC_FILE = "../data/dataset/testCOCO/annotations/panoptic.json"

  24. INVALID_FILE = "../data/dataset/testCOCO/annotations/invalid.json"

  25. LACKOFIMAGE_FILE = "../data/dataset/testCOCO/annotations/lack_of_images.json"

  26. INVALID_CATEGORY_ID_FILE = "../data/dataset/testCOCO/annotations/invalid_category_id.json"

  27. 

  28. def test_coco_detection():

  29.     data1 = ds.CocoDataset(DATA_DIR, annotation_file=ANNOTATION_FILE, task="Detection",

  30.                            decode=True, shuffle=False)

  31.     num_iter = 0

  32.     image_shape = []

  33.     bbox = []

  34.     category_id = []

  35.     for data in data1.create_dict_iterator():

  36.         image_shape.append(data["image"].shape)

  37.         bbox.append(data["bbox"])

  38.         category_id.append(data["category_id"])

  39.         num_iter += 1

  40.     assert num_iter == 6

  41.     assert image_shape[0] == (2268, 4032, 3)

  42.     assert image_shape[1] == (561, 595, 3)

  43.     assert image_shape[2] == (607, 585, 3)

  44.     assert image_shape[3] == (642, 675, 3)

  45.     assert image_shape[4] == (2268, 4032, 3)

  46.     assert image_shape[5] == (2268, 4032, 3)

  47.     assert np.array_equal(np.array([[10., 10., 10., 10.], [70., 70., 70., 70.]]), bbox[0])

  48.     assert np.array_equal(np.array([[20., 20., 20., 20.], [80., 80., 80.0, 80.]]), bbox[1])

  49.     assert np.array_equal(np.array([[30.0, 30.0, 30.0, 30.]]), bbox[2])

  50.     assert np.array_equal(np.array([[40., 40., 40., 40.]]), bbox[3])

  51.     assert np.array_equal(np.array([[50., 50., 50., 50.]]), bbox[4])

  52.     assert np.array_equal(np.array([[60., 60., 60., 60.]]), bbox[5])

  53.     assert np.array_equal(np.array([[1], [7]]), category_id[0])

  54.     assert np.array_equal(np.array([[2], [8]]), category_id[1])

  55.     assert np.array_equal(np.array([[3]]), category_id[2])

  56.     assert np.array_equal(np.array([[4]]), category_id[3])

  57.     assert np.array_equal(np.array([[5]]), category_id[4])

  58.     assert np.array_equal(np.array([[6]]), category_id[5])

  59. 

  60. def test_coco_stuff():

  61.     data1 = ds.CocoDataset(DATA_DIR, annotation_file=ANNOTATION_FILE, task="Stuff",

  62.                            decode=True, shuffle=False)

  63.     num_iter = 0

  64.     image_shape = []

  65.     segmentation = []

  66.     iscrowd = []

  67.     for data in data1.create_dict_iterator():

  68.         image_shape.append(data["image"].shape)

  69.         segmentation.append(data["segmentation"])

  70.         iscrowd.append(data["iscrowd"])

  71.         num_iter += 1

  72.     assert num_iter == 6

  73.     assert image_shape[0] == (2268, 4032, 3)

  74.     assert image_shape[1] == (561, 595, 3)

  75.     assert image_shape[2] == (607, 585, 3)

  76.     assert image_shape[3] == (642, 675, 3)

  77.     assert image_shape[4] == (2268, 4032, 3)

  78.     assert image_shape[5] == (2268, 4032, 3)

  79.     assert np.array_equal(np.array([[10., 12., 13., 14., 15., 16., 17., 18., 19., 20.],

  80.                                     [70., 72., 73., 74., 75., -1., -1., -1., -1., -1.]]),

  81.                           segmentation[0])

  82.     assert np.array_equal(np.array([[0], [0]]), iscrowd[0])

  83.     assert np.array_equal(np.array([[20.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0, 31.0],

  84.                                     [10.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0, 19.0, 20.0, -1.0]]),

  85.                           segmentation[1])

  86.     assert np.array_equal(np.array([[0], [1]]), iscrowd[1])

  87.     assert np.array_equal(np.array([[40., 42., 43., 44., 45., 46., 47., 48., 49., 40., 41., 42.]]), segmentation[2])

  88.     assert np.array_equal(np.array([[0]]), iscrowd[2])

  89.     assert np.array_equal(np.array([[50., 52., 53., 54., 55., 56., 57., 58., 59., 60., 61., 62., 63.]]),

  90.                           segmentation[3])

  91.     assert np.array_equal(np.array([[0]]), iscrowd[3])

  92.     assert np.array_equal(np.array([[60., 62., 63., 64., 65., 66., 67., 68., 69., 70., 71., 72., 73., 74.]]),

  93.                           segmentation[4])

  94.     assert np.array_equal(np.array([[0]]), iscrowd[4])

  95.     assert np.array_equal(np.array([[60., 62., 63., 64., 65., 66., 67.], [68., 69., 70., 71., 72., 73., 74.]]),

  96.                           segmentation[5])

  97.     assert np.array_equal(np.array([[0]]), iscrowd[5])

  98. 

  99. def test_coco_keypoint():

  100.     data1 = ds.CocoDataset(DATA_DIR, annotation_file=KEYPOINT_FILE, task="Keypoint",

  101.                            decode=True, shuffle=False)

  102.     num_iter = 0

  103.     image_shape = []

  104.     keypoints = []

  105.     num_keypoints = []

  106.     for data in data1.create_dict_iterator():

  107.         image_shape.append(data["image"].shape)

  108.         keypoints.append(data["keypoints"])

  109.         num_keypoints.append(data["num_keypoints"])

  110.         num_iter += 1

  111.     assert num_iter == 2

  112.     assert image_shape[0] == (2268, 4032, 3)

  113.     assert image_shape[1] == (561, 595, 3)

  114.     assert np.array_equal(np.array([[368., 61., 1., 369., 52., 2., 0., 0., 0., 382., 48., 2., 0., 0., 0., 368., 84., 2.,

  115.                                      435., 81., 2., 362., 125., 2., 446., 125., 2., 360., 153., 2., 0., 0., 0., 397.,

  116.                                      167., 1., 439., 166., 1., 369., 193., 2., 461., 234., 2., 361., 246., 2., 474.,

  117.                                      287., 2.]]), keypoints[0])

  118.     assert np.array_equal(np.array([[14]]), num_keypoints[0])

  119.     assert np.array_equal(np.array([[244., 139., 2., 0., 0., 0., 226., 118., 2., 0., 0., 0., 154., 159., 2., 143., 261.,

  120.                                      2., 135., 312., 2., 271., 423., 2., 184., 530., 2., 261., 280., 2., 347., 592., 2.,

  121.                                      0., 0., 0., 123., 596., 2., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.]]),

  122.                           keypoints[1])

  123.     assert np.array_equal(np.array([[10]]), num_keypoints[1])

  124. 

  125. def test_coco_panoptic():

  126.     data1 = ds.CocoDataset(DATA_DIR, annotation_file=PANOPTIC_FILE, task="Panoptic", decode=True, shuffle=False)

  127.     num_iter = 0

  128.     image_shape = []

  129.     bbox = []

  130.     category_id = []

  131.     iscrowd = []

  132.     area = []

  133.     for data in data1.create_dict_iterator():

  134.         image_shape.append(data["image"].shape)

  135.         bbox.append(data["bbox"])

  136.         category_id.append(data["category_id"])

  137.         iscrowd.append(data["iscrowd"])

  138.         area.append(data["area"])

  139.         num_iter += 1

  140.     assert num_iter == 2

  141.     assert image_shape[0] == (2268, 4032, 3)

  142.     assert np.array_equal(np.array([[472, 173, 36, 48], [340, 22, 154, 301], [486, 183, 30, 35]]), bbox[0])

  143.     assert np.array_equal(np.array([[1], [1], [2]]), category_id[0])

  144.     assert np.array_equal(np.array([[0], [0], [0]]), iscrowd[0])

  145.     assert np.array_equal(np.array([[705], [14062], [626]]), area[0])

  146.     assert image_shape[1] == (642, 675, 3)

  147.     assert np.array_equal(np.array([[103, 133, 229, 422], [243, 175, 93, 164]]), bbox[1])

  148.     assert np.array_equal(np.array([[1], [3]]), category_id[1])

  149.     assert np.array_equal(np.array([[0], [0]]), iscrowd[1])

  150.     assert np.array_equal(np.array([[43102], [6079]]), area[1])

  151. 

  152. def test_coco_detection_classindex():

  153.     data1 = ds.CocoDataset(DATA_DIR, annotation_file=ANNOTATION_FILE, task="Detection", decode=True)

  154.     class_index = data1.get_class_indexing()

  155.     assert class_index == {'person': [1], 'bicycle': [2], 'car': [3], 'cat': [4], 'dog': [5], 'monkey': [6],

  156.                            'bag': [7], 'orange': [8]}

  157.     num_iter = 0

  158.     for _ in data1.__iter__():

  159.         num_iter += 1

  160.     assert num_iter == 6

  161. 

  162. def test_coco_panootic_classindex():

  163.     data1 = ds.CocoDataset(DATA_DIR, annotation_file=PANOPTIC_FILE, task="Panoptic", decode=True)

  164.     class_index = data1.get_class_indexing()

  165.     assert class_index == {'person': [1, 1], 'bicycle': [2, 1], 'car': [3, 1]}

  166.     num_iter = 0

  167.     for _ in data1.__iter__():

  168.         num_iter += 1

  169.     assert num_iter == 2

  170. 

  171. def test_coco_case_0():

  172.     data1 = ds.CocoDataset(DATA_DIR, annotation_file=ANNOTATION_FILE, task="Detection", decode=True)

  173.     data1 = data1.shuffle(10)

  174.     data1 = data1.batch(3, pad_info={})

  175.     num_iter = 0

  176.     for _ in data1.create_dict_iterator():

  177.         num_iter += 1

  178.     assert num_iter == 2

  179. 

  180. def test_coco_case_1():

  181.     data1 = ds.CocoDataset(DATA_DIR, annotation_file=ANNOTATION_FILE, task="Detection", decode=True)

  182.     sizes = [0.5, 0.5]

  183.     randomize = False

  184.     dataset1, dataset2 = data1.split(sizes=sizes, randomize=randomize)

  185. 

  186.     num_iter = 0

  187.     for _ in dataset1.create_dict_iterator():

  188.         num_iter += 1

  189.     assert num_iter == 3

  190.     num_iter = 0

  191.     for _ in dataset2.create_dict_iterator():

  192.         num_iter += 1

  193.     assert num_iter == 3

  194. 

  195. def test_coco_case_2():

  196.     data1 = ds.CocoDataset(DATA_DIR, annotation_file=ANNOTATION_FILE, task="Detection", decode=True)

  197.     resize_op = vision.Resize((224, 224))

  198. 

  199.     data1 = data1.map(input_columns=["image"], operations=resize_op)

  200.     data1 = data1.repeat(4)

  201.     num_iter = 0

  202.     for _ in data1.__iter__():

  203.         num_iter += 1

  204.     assert num_iter == 24

  205. 

  206. def test_coco_case_3():

  207.     data1 = ds.CocoDataset(DATA_DIR_2, annotation_file=ANNOTATION_FILE, task="Detection", decode=True)

  208.     resize_op = vision.Resize((224, 224))

  209. 

  210.     data1 = data1.map(input_columns=["image"], operations=resize_op)

  211.     data1 = data1.repeat(4)

  212.     num_iter = 0

  213.     for _ in data1.__iter__():

  214.         num_iter += 1

  215.     assert num_iter == 24

  216. 

  217. def test_coco_case_exception():

  218.     try:

  219.         data1 = ds.CocoDataset("path_not_exist/", annotation_file=ANNOTATION_FILE, task="Detection")

  220.         for _ in data1.__iter__():

  221.             pass

  222.         assert False

  223.     except ValueError as e:

  224.         assert "does not exist or permission denied" in str(e)

  225. 

  226.     try:

  227.         data1 = ds.CocoDataset(DATA_DIR, annotation_file="./file_not_exist", task="Detection")

  228.         for _ in data1.__iter__():

  229.             pass

  230.         assert False

  231.     except ValueError as e:

  232.         assert "does not exist or permission denied" in str(e)

  233. 

  234.     try:

  235.         data1 = ds.CocoDataset(DATA_DIR, annotation_file=ANNOTATION_FILE, task="Invalid task")

  236.         for _ in data1.__iter__():

  237.             pass

  238.         assert False

  239.     except ValueError as e:

  240.         assert "Invalid task type" in str(e)

  241. 

  242.     try:

  243.         data1 = ds.CocoDataset(DATA_DIR, annotation_file=LACKOFIMAGE_FILE, task="Detection")

  244.         for _ in data1.__iter__():

  245.             pass

  246.         assert False

  247.     except RuntimeError as e:

  248.         assert "Invalid node found in json" in str(e)

  249. 

  250.     try:

  251.         data1 = ds.CocoDataset(DATA_DIR, annotation_file=INVALID_CATEGORY_ID_FILE, task="Detection")

  252.         for _ in data1.__iter__():

  253.             pass

  254.         assert False

  255.     except RuntimeError as e:

  256.         assert "category_id can't find in categories" in str(e)

  257. 

  258.     try:

  259.         data1 = ds.CocoDataset(DATA_DIR, annotation_file=INVALID_FILE, task="Detection")

  260.         for _ in data1.__iter__():

  261.             pass

  262.         assert False

  263.     except RuntimeError as e:

  264.         assert "json.exception.parse_error" in str(e)

  265. 

  266.     try:

  267.         sampler = ds.PKSampler(3)

  268.         data1 = ds.CocoDataset(DATA_DIR, annotation_file=INVALID_FILE, task="Detection", sampler=sampler)

  269.         for _ in data1.__iter__():

  270.             pass

  271.         assert False

  272.     except ValueError as e:

  273.         assert "CocoDataset doesn't support PKSampler" in str(e)

  274. 

  275. 

  276. if __name__ == '__main__':

  277.     test_coco_detection()

  278.     test_coco_stuff()

  279.     test_coco_keypoint()

  280.     test_coco_panoptic()

  281.     test_coco_detection_classindex()

  282.     test_coco_panootic_classindex()

  283.     test_coco_case_0()

  284.     test_coco_case_1()

  285.     test_coco_case_2()

  286.     test_coco_case_3()

  287.     test_coco_case_exception()