Spaces:
Running
Running
| # Copyright 2017 The TensorFlow Authors. All Rights Reserved. | |
| # | |
| # Licensed under the Apache License, Version 2.0 (the "License"); | |
| # you may not use this file except in compliance with the License. | |
| # You may obtain a copy of the License at | |
| # | |
| # http://www.apache.org/licenses/LICENSE-2.0 | |
| # | |
| # Unless required by applicable law or agreed to in writing, software | |
| # distributed under the License is distributed on an "AS IS" BASIS, | |
| # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. | |
| # See the License for the specific language governing permissions and | |
| # limitations under the License. | |
| # ============================================================================== | |
| """Tests for object_detection.data_decoders.tf_example_parser.""" | |
| import numpy as np | |
| import numpy.testing as np_testing | |
| import tensorflow.compat.v1 as tf | |
| from object_detection.core import standard_fields as fields | |
| from object_detection.metrics import tf_example_parser | |
| class TfExampleDecoderTest(tf.test.TestCase): | |
| def _Int64Feature(self, value): | |
| return tf.train.Feature(int64_list=tf.train.Int64List(value=value)) | |
| def _FloatFeature(self, value): | |
| return tf.train.Feature(float_list=tf.train.FloatList(value=value)) | |
| def _BytesFeature(self, value): | |
| return tf.train.Feature(bytes_list=tf.train.BytesList(value=[value])) | |
| def testParseDetectionsAndGT(self): | |
| source_id = b'abc.jpg' | |
| # y_min, x_min, y_max, x_max | |
| object_bb = np.array([[0.0, 0.5, 0.3], [0.0, 0.1, 0.6], [1.0, 0.6, 0.8], | |
| [1.0, 0.6, 0.7]]).transpose() | |
| detection_bb = np.array([[0.1, 0.2], [0.0, 0.8], [1.0, 0.6], | |
| [1.0, 0.85]]).transpose() | |
| object_class_label = [1, 1, 2] | |
| object_difficult = [1, 0, 0] | |
| object_group_of = [0, 0, 1] | |
| verified_labels = [1, 2, 3, 4] | |
| detection_class_label = [2, 1] | |
| detection_score = [0.5, 0.3] | |
| features = { | |
| fields.TfExampleFields.source_id: | |
| self._BytesFeature(source_id), | |
| fields.TfExampleFields.object_bbox_ymin: | |
| self._FloatFeature(object_bb[:, 0].tolist()), | |
| fields.TfExampleFields.object_bbox_xmin: | |
| self._FloatFeature(object_bb[:, 1].tolist()), | |
| fields.TfExampleFields.object_bbox_ymax: | |
| self._FloatFeature(object_bb[:, 2].tolist()), | |
| fields.TfExampleFields.object_bbox_xmax: | |
| self._FloatFeature(object_bb[:, 3].tolist()), | |
| fields.TfExampleFields.detection_bbox_ymin: | |
| self._FloatFeature(detection_bb[:, 0].tolist()), | |
| fields.TfExampleFields.detection_bbox_xmin: | |
| self._FloatFeature(detection_bb[:, 1].tolist()), | |
| fields.TfExampleFields.detection_bbox_ymax: | |
| self._FloatFeature(detection_bb[:, 2].tolist()), | |
| fields.TfExampleFields.detection_bbox_xmax: | |
| self._FloatFeature(detection_bb[:, 3].tolist()), | |
| fields.TfExampleFields.detection_class_label: | |
| self._Int64Feature(detection_class_label), | |
| fields.TfExampleFields.detection_score: | |
| self._FloatFeature(detection_score), | |
| } | |
| example = tf.train.Example(features=tf.train.Features(feature=features)) | |
| parser = tf_example_parser.TfExampleDetectionAndGTParser() | |
| results_dict = parser.parse(example) | |
| self.assertIsNone(results_dict) | |
| features[fields.TfExampleFields.object_class_label] = ( | |
| self._Int64Feature(object_class_label)) | |
| features[fields.TfExampleFields.object_difficult] = ( | |
| self._Int64Feature(object_difficult)) | |
| example = tf.train.Example(features=tf.train.Features(feature=features)) | |
| results_dict = parser.parse(example) | |
| self.assertIsNotNone(results_dict) | |
| self.assertEqual(source_id, results_dict[fields.DetectionResultFields.key]) | |
| np_testing.assert_almost_equal( | |
| object_bb, results_dict[fields.InputDataFields.groundtruth_boxes]) | |
| np_testing.assert_almost_equal( | |
| detection_bb, | |
| results_dict[fields.DetectionResultFields.detection_boxes]) | |
| np_testing.assert_almost_equal( | |
| detection_score, | |
| results_dict[fields.DetectionResultFields.detection_scores]) | |
| np_testing.assert_almost_equal( | |
| detection_class_label, | |
| results_dict[fields.DetectionResultFields.detection_classes]) | |
| np_testing.assert_almost_equal( | |
| object_difficult, | |
| results_dict[fields.InputDataFields.groundtruth_difficult]) | |
| np_testing.assert_almost_equal( | |
| object_class_label, | |
| results_dict[fields.InputDataFields.groundtruth_classes]) | |
| parser = tf_example_parser.TfExampleDetectionAndGTParser() | |
| features[fields.TfExampleFields.object_group_of] = ( | |
| self._Int64Feature(object_group_of)) | |
| example = tf.train.Example(features=tf.train.Features(feature=features)) | |
| results_dict = parser.parse(example) | |
| self.assertIsNotNone(results_dict) | |
| np_testing.assert_equal( | |
| object_group_of, | |
| results_dict[fields.InputDataFields.groundtruth_group_of]) | |
| features[fields.TfExampleFields.image_class_label] = ( | |
| self._Int64Feature(verified_labels)) | |
| example = tf.train.Example(features=tf.train.Features(feature=features)) | |
| results_dict = parser.parse(example) | |
| self.assertIsNotNone(results_dict) | |
| np_testing.assert_equal( | |
| verified_labels, | |
| results_dict[fields.InputDataFields.groundtruth_image_classes]) | |
| def testParseString(self): | |
| string_val = b'abc' | |
| features = {'string': self._BytesFeature(string_val)} | |
| example = tf.train.Example(features=tf.train.Features(feature=features)) | |
| parser = tf_example_parser.StringParser('string') | |
| result = parser.parse(example) | |
| self.assertIsNotNone(result) | |
| self.assertEqual(result, string_val) | |
| parser = tf_example_parser.StringParser('another_string') | |
| result = parser.parse(example) | |
| self.assertIsNone(result) | |
| def testParseFloat(self): | |
| float_array_val = [1.5, 1.4, 2.0] | |
| features = {'floats': self._FloatFeature(float_array_val)} | |
| example = tf.train.Example(features=tf.train.Features(feature=features)) | |
| parser = tf_example_parser.FloatParser('floats') | |
| result = parser.parse(example) | |
| self.assertIsNotNone(result) | |
| np_testing.assert_almost_equal(result, float_array_val) | |
| parser = tf_example_parser.StringParser('another_floats') | |
| result = parser.parse(example) | |
| self.assertIsNone(result) | |
| def testInt64Parser(self): | |
| int_val = [1, 2, 3] | |
| features = {'ints': self._Int64Feature(int_val)} | |
| example = tf.train.Example(features=tf.train.Features(feature=features)) | |
| parser = tf_example_parser.Int64Parser('ints') | |
| result = parser.parse(example) | |
| self.assertIsNotNone(result) | |
| np_testing.assert_almost_equal(result, int_val) | |
| parser = tf_example_parser.Int64Parser('another_ints') | |
| result = parser.parse(example) | |
| self.assertIsNone(result) | |
| def testBoundingBoxParser(self): | |
| bounding_boxes = np.array([[0.0, 0.5, 0.3], [0.0, 0.1, 0.6], | |
| [1.0, 0.6, 0.8], [1.0, 0.6, 0.7]]).transpose() | |
| features = { | |
| 'ymin': self._FloatFeature(bounding_boxes[:, 0]), | |
| 'xmin': self._FloatFeature(bounding_boxes[:, 1]), | |
| 'ymax': self._FloatFeature(bounding_boxes[:, 2]), | |
| 'xmax': self._FloatFeature(bounding_boxes[:, 3]) | |
| } | |
| example = tf.train.Example(features=tf.train.Features(feature=features)) | |
| parser = tf_example_parser.BoundingBoxParser('xmin', 'ymin', 'xmax', 'ymax') | |
| result = parser.parse(example) | |
| self.assertIsNotNone(result) | |
| np_testing.assert_almost_equal(result, bounding_boxes) | |
| parser = tf_example_parser.BoundingBoxParser('xmin', 'ymin', 'xmax', | |
| 'another_ymax') | |
| result = parser.parse(example) | |
| self.assertIsNone(result) | |
| if __name__ == '__main__': | |
| tf.test.main() | |