|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
"""Tests for object_detection.data_decoders.tf_example_parser.""" |
|
|
|
import numpy as np |
|
import numpy.testing as np_testing |
|
import tensorflow 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 = 'abc.jpg' |
|
|
|
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 = '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() |
|
|