def get_split(split_name, dataset_dir=None):
"""Gets a dataset tuple with instructions for reading cifar100.
Args:
split_name: A train/test split name.
dataset_dir: The base directory of the dataset sources.
Returns:
A `Dataset` namedtuple. Image tensors are integers in [0, 255].
Raises:
ValueError: if `split_name` is not a valid train/test split.
"""
if split_name not in _SPLITS_TO_SIZES:
raise ValueError('split name %s was not recognized.' % split_name)
file_pattern = os.path.join(dataset_dir, _FILE_PATTERN % split_name)
keys_to_features = {
'image/encoded':
tf.FixedLenFeature((), tf.string, default_value=''),
'image/format':
tf.FixedLenFeature((), tf.string, default_value=''),
'image/class/label':
tf.FixedLenFeature([1],
tf.int64,
default_value=tf.zeros([1], dtype=tf.int64)),
'image/class/fine_label':
tf.FixedLenFeature([1],
tf.int64,
default_value=tf.zeros([1], dtype=tf.int64)),
}
if split_name == 'train':
items_to_handlers = {
'image': tfexample_decoder.Image(shape=[32, 32, 3]),
'label': tfexample_decoder.Tensor('image/class/label'),
}
else:
items_to_handlers = {
'image': tfexample_decoder.Image(shape=[32, 32, 3]),
'label': tfexample_decoder.Tensor('image/class/fine_label'),
}
decoder = tfexample_decoder.TFExampleDecoder(keys_to_features,
items_to_handlers)
return dataset.Dataset(data_sources=file_pattern,
reader=tf.TFRecordReader,
decoder=decoder,
num_samples=_SPLITS_TO_SIZES[split_name],
num_classes=_NUM_CLASSES,
items_to_descriptions=_ITEMS_TO_DESCRIPTIONS)
def _create_tfrecord_dataset(tmpdir):
if not gfile.Exists(tmpdir):
gfile.MakeDirs(tmpdir)
data_sources = test_utils.create_tfrecord_files(tmpdir, num_files=1)
keys_to_features = {
'image/encoded':
parsing_ops.FixedLenFeature(
shape=(), dtype=dtypes.string, default_value=''),
'image/format':
parsing_ops.FixedLenFeature(
shape=(), dtype=dtypes.string, default_value='jpeg'),
'image/class/label':
parsing_ops.FixedLenFeature(
shape=[1],
dtype=dtypes.int64,
default_value=array_ops.zeros(
[1], dtype=dtypes.int64))
}
items_to_handlers = {
'image': tfexample_decoder.Image(),
'label': tfexample_decoder.Tensor('image/class/label'),
}
decoder = tfexample_decoder.TFExampleDecoder(keys_to_features,
items_to_handlers)
return dataset.Dataset(
data_sources=data_sources,
reader=io_ops.TFRecordReader,
decoder=decoder,
num_samples=100,
items_to_descriptions=None)
def create_dataset(self, data_source):
keys_to_features = {
'image/encoded': tf.FixedLenFeature(shape=(), dtype=tf.string, default_value=''),
'image/format': tf.FixedLenFeature(shape=(), dtype=tf.string, default_value='png'),
'image/object/bbox/xmin': tf.FixedLenFeature(shape=(), dtype= tf.string, default_value=''),
'image/object/bbox/xmax': tf.FixedLenFeature(shape=(), dtype= tf.string, default_value=''),
'image/object/bbox/ymin': tf.FixedLenFeature(shape=(), dtype= tf.string, default_value=''),
'image/object/bbox/ymax': tf.FixedLenFeature(shape=(), dtype= tf.string, default_value=''),
'image/object/bbox/label': tf.FixedLenFeature(shape=(), dtype = tf.string, default_value=''),
'image/object/size': tf.FixedLenFeature(shape=(), dtype = tf.int64, default_value=0)
}
items_to_handlers = {
'image': tfexample_decoder.Image(),
'xmin': tfexample_decoder.Tensor('image/object/bbox/xmin'),
'xmax': tfexample_decoder.Tensor('image/object/bbox/xmax'),
'ymin': tfexample_decoder.Tensor('image/object/bbox/ymin'),
'ymax': tfexample_decoder.Tensor('image/object/bbox/ymax'),
#'bbox': tfexample_decoder.BoundingBox(prefix='image/object/bbox/'),
'label': tfexample_decoder.Tensor('image/object/bbox/label'),
'size': tfexample_decoder.Tensor('image/object/size')
}
decoder = tfexample_decoder.TFExampleDecoder(keys_to_features, items_to_handlers)
return dataset.Dataset(data_sources=data_source, reader = tf.TFRecordReader,
decoder=decoder, num_samples = 1, items_to_descriptions=None)
def get_split(split_name='train',
dataset_dir=None,
num_classes_per_attribute=None):
"""Gets a dataset tuple with instructions for reading 2D shapes data.
Args:
split_name: A train/test split name.
dataset_dir: The base directory of the dataset sources.
num_classes_per_attribute: The number of labels for the classfication
problem corresponding to each attribute. For example, if the first
attribute is "shape" and there are three possible shapes, then
then provide a value 3 in the first index, and so on.
Returns:
A `Dataset` namedtuple.
metadata: A dictionary with some metadata about the dataset we just
constructed.
Raises:
ValueError: if `split_name` is not a valid train/test split.
"""
if split_name not in _SPLITS_TO_SIZES:
raise ValueError('split name %s was not recognized.' % split_name)
if num_classes_per_attribute is None:
num_classes_per_attribute = _NUM_CLASSES_PER_ATTRIBUTE
if dataset_dir is None:
dataset_dir = _DATASET_DIR
file_pattern = os.path.join(dataset_dir, _FILE_PATTERN % (_SPLIT_TYPE, split_name))
keys_to_features = {
'image/encoded': tf.FixedLenFeature((), tf.string, default_value=''),
'image/format': tf.FixedLenFeature((), tf.string, default_value='raw'),
'labels': tf.FixedLenFeature([len(num_classes_per_attribute)], tf.int64),
'latents': tf.FixedLenFeature([_NUM_LATENTS], tf.float32),
}
items_to_handlers = {
'image': tfexample_decoder.Image(shape=[64, 64, 3]),
'labels': tfexample_decoder.Tensor('labels'),
'latents': tfexample_decoder.Tensor('latents'),
}
decoder = tfexample_decoder.TFExampleDecoder(keys_to_features,
items_to_handlers)
metadata = {
'num_classes_per_attribute': num_classes_per_attribute,
'split_type': _SPLIT_TYPE
}
return dataset.Dataset(
data_sources=file_pattern,
reader=tf.TFRecordReader,
decoder=decoder,
num_samples=_SPLITS_TO_SIZES[split_name],
items_to_descriptions=_ITEMS_TO_DESCRIPTIONS), metadata
def test_decode_example_with_jpeg_encoding_at_16Bit_causes_error(self):
image_shape = (2, 3, 3)
unused_image, serialized_example = self.generate_image(
image_format='jpeg', image_shape=image_shape)
with self.assertRaises((TypeError, ValueError)):
self.run_decode_example(serialized_example,
tfexample_decoder.Image(dtype=dtypes.uint16),
image_format='jpeg')
def testDecodeExampleWithJpegEncodingAt16BitCausesError(self):
image_shape = (2, 3, 3)
unused_image, serialized_example = self.GenerateImage(
image_format='jpeg', image_shape=image_shape)
with self.assertRaises(TypeError):
unused_decoded_image = self.RunDecodeExample(
serialized_example,
tfexample_decoder.Image(dtype=dtypes.uint16),
image_format='jpeg')
def test_decode_example_with_RAW_encoding(self):
image_shape = (2, 3, 3)
image, serialized_example = self.generate_image(image_format='RAW', image_shape=image_shape)
decoded_image = self.run_decode_example(
serialized_example,
tfexample_decoder.Image(shape=image_shape),
image_format='RAW')
self.assertAllClose(image, decoded_image, atol=0)
def test_decode_example_with_jpeg_encoding(self):
image_shape = (2, 3, 3)
image, serialized_example = self.generate_image(image_format='jpeg',
image_shape=image_shape)
decoded_image = self.run_decode_example(
serialized_example, tfexample_decoder.Image(), image_format='jpeg')
# Need to use a tolerance of 1 because of noise in the jpeg encode/decode
self.assertAllClose(image, decoded_image, atol=1.001)
def testDecodeExampleWithJpegEncodingAt16BitDoesNotCauseError(self):
image_shape = (2, 3, 3)
# Image has type uint8 but decoding at uint16 should not cause problems.
image, serialized_example = self.GenerateImage(image_format='jpeg',
image_shape=image_shape)
decoded_image = self.RunDecodeExample(
serialized_example,
tfexample_decoder.Image(dtype=dtypes.uint16),
image_format='jpeg')
self.assertAllClose(image, decoded_image, atol=1.001)
def testDecodeExampleWithRAWEncoding(self):
image_shape = (2, 3, 3)
image, serialized_example = self.GenerateImage(image_format='RAW',
image_shape=image_shape)
decoded_image = self.RunDecodeExample(
serialized_example,
tfexample_decoder.Image(shape=image_shape),
image_format='RAW')
self.assertAllClose(image, decoded_image, atol=0)
def testDecodeExampleWithRawEncodingFloatDtype(self):
image_shape = (2, 3, 3)
image, serialized_example = self.GenerateImage(
image_format='raw', image_shape=image_shape, image_dtype=np.float32)
decoded_image = self.RunDecodeExample(
serialized_example,
tfexample_decoder.Image(shape=image_shape, dtype=dtypes.float32),
image_format='raw')
self.assertAllClose(image, decoded_image, atol=0)
def testDecodeExampleWithJpegEncodingAt16BitCausesError(self):
image_shape = (2, 3, 3)
unused_image, serialized_example = self.GenerateImage(
image_format='jpeg', image_shape=image_shape)
# decode_raw support uint16 now so ValueError will be thrown instead.
with self.assertRaisesRegexp(
ValueError,
'true_fn and false_fn must have the same type: uint16, uint8'):
unused_decoded_image = self.RunDecodeExample(
serialized_example,
tfexample_decoder.Image(dtype=dtypes.uint16),
image_format='jpeg')
def test_decode_example_with_no_shape_info(self):
test_image_channels = [1, 3]
for channels in test_image_channels:
image_shape = (2, 3, channels)
_, serialized_example = self.generate_image(image_format='jpeg',
image_shape=image_shape)
tf_decoded_image = self.decode_example(
serialized_example,
tfexample_decoder.Image(shape=None, channels=channels),
image_format='jpeg')
self.assertEqual(tf_decoded_image.get_shape().ndims, 3)
def testDecodeExampleWithJpegEncodingAt16BitCausesError(self):
image_shape = (2, 3, 3)
unused_image, serialized_example = self.GenerateImage(
image_format='jpeg', image_shape=image_shape)
expected_regex = (
'jpeg decoder can only be used to decode to tf.uint8 but '
'.* was requested for a jpeg image.')
with self.assertRaisesRegexp(ValueError, expected_regex):
unused_decoded_image = self.RunDecodeExample(
serialized_example,
tfexample_decoder.Image(dtype=dtypes.uint16),
image_format='jpeg')
def test_decode_example_with_PNG_encoding(self):
test_image_channels = [1, 3, 4]
for channels in test_image_channels:
image_shape = (2, 3, channels)
image, serialized_example = self.generate_image(
image_format='PNG', image_shape=image_shape)
decoded_image = self.run_decode_example(
serialized_example,
tfexample_decoder.Image(channels=channels),
image_format='PNG')
self.assertAllClose(image, decoded_image, atol=0)
def testDecodeExampleWithPNGEncoding(self):
test_image_channels = [1, 3, 4]
for channels in test_image_channels:
image_shape = (2, 3, channels)
image, serialized_example = self.GenerateImage(
image_format='PNG', image_shape=image_shape)
decoded_image = self.RunDecodeExample(
serialized_example,
tfexample_decoder.Image(channels=channels),
image_format='PNG')
self.assertAllClose(image, decoded_image, atol=0)
def testDecodeExampleWithJPEGEncoding(self):
test_image_channels = [1, 3]
for channels in test_image_channels:
image_shape = (2, 3, channels)
image, serialized_example = self.GenerateImage(
image_format='JPEG', image_shape=image_shape)
decoded_image = self.RunDecodeExample(
serialized_example,
tfexample_decoder.Image(channels=channels),
image_format='JPEG')
# Need to use a tolerance of 1 because of noise in the jpeg encode/decode
self.assertAllClose(image, decoded_image, atol=1.001)
def make_data_provider(self, **kwargs):
context_keys_to_features = {
self.params["image_field"]:
tf.FixedLenFeature([], dtype=tf.string),
"image/format":
tf.FixedLenFeature([],
dtype=tf.string,
default_value=self.params["image_format"]),
}
sequence_keys_to_features = {
self.params["caption_ids_field"]:
tf.FixedLenSequenceFeature([], dtype=tf.int64),
self.params["caption_tokens_field"]:
tf.FixedLenSequenceFeature([], dtype=tf.string)
}
items_to_handlers = {
"image":
tfexample_decoder.Image(image_key=self.params["image_field"],
format_key="image/format",
channels=3),
"target_ids":
tfexample_decoder.Tensor(self.params["caption_ids_field"]),
"target_tokens":
tfexample_decoder.Tensor(self.params["caption_tokens_field"]),
"target_len":
tfexample_decoder.ItemHandlerCallback(
keys=[self.params["caption_tokens_field"]],
func=lambda x: tf.size(x[self.params["caption_tokens_field"]]))
}
decoder = TFSEquenceExampleDecoder(context_keys_to_features,
sequence_keys_to_features,
items_to_handlers)
dataset = tf.contrib.slim.dataset.Dataset(
data_sources=self.params["files"],
reader=tf.TFRecordReader,
decoder=decoder,
num_samples=None,
items_to_descriptions={})
return tf.contrib.slim.dataset_data_provider.DatasetDataProvider(
dataset=dataset,
shuffle=self.params["shuffle"],
num_epochs=self.params["num_epochs"],
**kwargs)
def items_to_handlers(self):
"""Items to handlers
"""
default = {
'image':
tfexample_decoder.Image(shape=self.params['image_shape'],
image_key='image/encoded',
format_key='image/format'),
'label':
tfexample_decoder.Tensor(tensor_key='image/class'),
'text':
tfexample_decoder.Tensor(tensor_key='image/text'),
'length':
tfexample_decoder.Tensor(tensor_key='image/text_length'),
'name':
tfexample_decoder.Tensor(tensor_key='image/name')
}
return default
def testDecodeExampleWithRepeatedImages(self):
image_shape = (2, 3, 3)
image_format = 'png'
image, _ = self.GenerateImage(image_format=image_format,
image_shape=image_shape)
tf_encoded = self._Encoder(image, image_format)
with self.test_session():
tf_string = tf_encoded.eval()
example = example_pb2.Example(features=feature_pb2.Features(
feature={
'image/encoded':
feature_pb2.Feature(bytes_list=feature_pb2.BytesList(
value=[tf_string, tf_string])),
'image/format':
self._StringFeature(image_format),
}))
serialized_example = example.SerializeToString()
with self.test_session():
serialized_example = array_ops.reshape(serialized_example,
shape=[])
decoder = tfexample_decoder.TFExampleDecoder(
keys_to_features={
'image/encoded':
parsing_ops.FixedLenFeature((2, ), dtypes.string),
'image/format':
parsing_ops.FixedLenFeature((),
dtypes.string,
default_value=image_format),
},
items_to_handlers={
'image': tfexample_decoder.Image(repeated=True)
})
[tf_image] = decoder.decode(serialized_example, ['image'])
output_image = tf_image.eval()
self.assertEqual(output_image.shape, (2, 2, 3, 3))
self.assertAllEqual(np.squeeze(output_image[0, :, :, :]), image)
self.assertAllEqual(np.squeeze(output_image[1, :, :, :]), image)
