def _get_split(file_pattern, num_samples, num_views, image_size, vox_size): """Get dataset.Dataset for the given dataset file pattern and properties.""" # A dictionary from TF-Example keys to tf.FixedLenFeature instance. keys_to_features = { 'image': tf.FixedLenFeature( shape=[num_views, image_size, image_size, 3], dtype=tf.float32, default_value=None), 'mask': tf.FixedLenFeature( shape=[num_views, image_size, image_size, 1], dtype=tf.float32, default_value=None), 'vox': tf.FixedLenFeature( shape=[vox_size, vox_size, vox_size, 1], dtype=tf.float32, default_value=None), } items_to_handler = { 'image': tfexample_decoder.Tensor( 'image', shape=[num_views, image_size, image_size, 3]), 'mask': tfexample_decoder.Tensor( 'mask', shape=[num_views, image_size, image_size, 1]), 'vox': tfexample_decoder.Tensor( 'vox', shape=[vox_size, vox_size, vox_size, 1]) } decoder = tfexample_decoder.TFExampleDecoder( keys_to_features, items_to_handler) return dataset.Dataset( data_sources=file_pattern, reader=tf.TFRecordReader, decoder=decoder, num_samples=num_samples, items_to_descriptions=_ITEMS_TO_DESCRIPTIONS)
def test_decode_example_shape_key_tensor(self): np_image = np.random.rand(2, 3, 1).astype('f') np_labels = np.array([[[1], [2], [3]], [[4], [5], [6]]]) example = example_pb2.Example(features=feature_pb2.Features(feature={ 'image': self._encode_float_feature(np_image), 'image/shape': self._encode_int64_feature(np.array(np_image.shape)), 'labels': self._encode_int64_feature(np_labels), 'labels/shape': self._encode_int64_feature(np.array(np_labels.shape)), })) serialized_example = example.SerializeToString() with self.test_session(): serialized_example = array_ops.reshape(serialized_example, shape=[]) keys_to_features = { 'image': parsing_ops.VarLenFeature(dtype=dtypes.float32), 'image/shape': parsing_ops.VarLenFeature(dtype=dtypes.int64), 'labels': parsing_ops.VarLenFeature(dtype=dtypes.int64), 'labels/shape': parsing_ops.VarLenFeature(dtype=dtypes.int64), } items_to_handlers = { 'image': tfexample_decoder.Tensor('image', shape_keys='image/shape'), 'labels': tfexample_decoder.Tensor('labels', shape_keys='labels/shape'), } decoder = TFExampleDecoder(keys_to_features, items_to_handlers) [tf_image, tf_labels] = decoder.decode(serialized_example, ['image', 'labels']) self.assertAllEqual(tf_image.eval(), np_image) self.assertAllEqual(tf_labels.eval(), np_labels)
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 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 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 testDecodeExampleMultiShapeKeyTensor(self): np_image = np.random.rand(2, 3, 1).astype('f') np_labels = np.array([[[1], [2], [3]], [[4], [5], [6]]]) height, width, depth = np_labels.shape example = example_pb2.Example( features=feature_pb2.Features( feature={ 'image': self._EncodedFloatFeature(np_image), 'image/shape': self._EncodedInt64Feature(np.array(np_image.shape)), 'labels': self._EncodedInt64Feature(np_labels), 'labels/height': self._EncodedInt64Feature(np.array([height])), 'labels/width': self._EncodedInt64Feature(np.array([width])), 'labels/depth': self._EncodedInt64Feature(np.array([depth])), })) serialized_example = example.SerializeToString() with self.cached_session(): serialized_example = array_ops.reshape(serialized_example, shape=[]) keys_to_features = { 'image': parsing_ops.VarLenFeature(dtype=dtypes.float32), 'image/shape': parsing_ops.VarLenFeature(dtype=dtypes.int64), 'labels': parsing_ops.VarLenFeature(dtype=dtypes.int64), 'labels/height': parsing_ops.VarLenFeature(dtype=dtypes.int64), 'labels/width': parsing_ops.VarLenFeature(dtype=dtypes.int64), 'labels/depth': parsing_ops.VarLenFeature(dtype=dtypes.int64), } items_to_handlers = { 'image': tfexample_decoder.Tensor('image', shape_keys='image/shape'), 'labels': tfexample_decoder.Tensor( 'labels', shape_keys=['labels/height', 'labels/width', 'labels/depth']), } decoder = tfexample_decoder.TFExampleDecoder(keys_to_features, items_to_handlers) [tf_image, tf_labels] = decoder.decode(serialized_example, ['image', 'labels']) self.assertAllEqual(tf_image.eval(), np_image) self.assertAllEqual(tf_labels.eval(), np_labels)
def testDecodeExampleWithTensor(self): tensor_shape = (2, 3, 1) np_array = np.random.rand(2, 3, 1) example = example_pb2.Example(features=feature_pb2.Features( feature={ 'image/depth_map': self._EncodedFloatFeature(np_array), })) serialized_example = example.SerializeToString() with self.test_session(): serialized_example = array_ops.reshape(serialized_example, shape=[]) keys_to_features = { 'image/depth_map': parsing_ops.FixedLenFeature( tensor_shape, dtypes.float32, default_value=array_ops.zeros(tensor_shape)) } items_to_handlers = { 'depth': tfexample_decoder.Tensor('image/depth_map') } decoder = tfexample_decoder.TFExampleDecoder( keys_to_features, items_to_handlers) [tf_depth] = decoder.decode(serialized_example, ['depth']) depth = tf_depth.eval() self.assertAllClose(np_array, depth)
def testDecodeExampleWithFixLenTensorWithShape(self): np_array = np.array([[1, 2, 3], [4, 5, 6]]) example = example_pb2.Example(features=feature_pb2.Features( feature={ 'labels': self._EncodedInt64Feature(np_array), })) serialized_example = example.SerializeToString() with self.test_session(): serialized_example = array_ops.reshape(serialized_example, shape=[]) keys_to_features = { 'labels': parsing_ops.FixedLenFeature(np_array.shape, dtype=dtypes.int64), } items_to_handlers = { 'labels': tfexample_decoder.Tensor('labels', shape=np_array.shape), } decoder = tfexample_decoder.TFExampleDecoder( keys_to_features, items_to_handlers) [tf_labels] = decoder.decode(serialized_example, ['labels']) labels = tf_labels.eval() self.assertAllEqual(labels, np_array)
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 testDecodeExampleWithStringTensor(self): tensor_shape = (2, 3, 1) np_array = np.array([[['ab'], ['cd'], ['ef']], [['ghi'], ['jkl'], ['mnop']]]) example = example_pb2.Example(features=feature_pb2.Features( feature={ 'labels': self._BytesFeature(np_array), })) serialized_example = example.SerializeToString() with self.test_session(): serialized_example = array_ops.reshape(serialized_example, shape=[]) keys_to_features = { 'labels': parsing_ops.FixedLenFeature(tensor_shape, dtypes.string, default_value=constant_op.constant( '', shape=tensor_shape, dtype=dtypes.string)) } items_to_handlers = { 'labels': tfexample_decoder.Tensor('labels'), } decoder = tfexample_decoder.TFExampleDecoder( keys_to_features, items_to_handlers) [tf_labels] = decoder.decode(serialized_example, ['labels']) labels = tf_labels.eval() labels = labels.astype(np_array.dtype) self.assertTrue(np.array_equal(np_array, labels))
def make_data_provider(self, **kwargs): data_files = [] tf.logging.info(self.params["file_input_pattern"].split(",")) for pattern in self.params["file_input_pattern"].split(","): data_files.extend(tf.gfile.Glob(pattern)) if not data_files: tf.logging.fatal("Found no input files matching %s", self.params["file_input_pattern"]) else: tf.logging.info("Prefetching values from %d files matching %s", len(data_files), self.params["file_input_pattern"]) splitter_target = split_tokens_decoder.SplitTokensDecoder( tokens_feature_name="target_tokens", length_feature_name="target_len", prepend_token="SEQUENCE_START", append_token="SEQUENCE_END", delimiter=self.params["target_delimiter"]) context_keys_to_features = { self.params["caption_tokens_field"]: tf.FixedLenFeature( [], dtype=tf.string), } sequence_keys_to_features = { self.params["video_field"]: tf.FixedLenSequenceFeature( [], dtype=tf.string), } items_to_handlers = { "source_tokens": tfexample_decoder.Tensor(self.params["video_field"]), "source_len": tfexample_decoder.ItemHandlerCallback( keys=[self.params["video_field"]], func=lambda x: tf.size(x[self.params["video_field"]])), "target_tokens": tfexample_decoder.ItemHandlerCallback( keys=[self.params["caption_tokens_field"]], func=lambda dict: splitter_target.decode( dict[self.params["caption_tokens_field"]], ["target_tokens"])[0]), "target_len": tfexample_decoder.ItemHandlerCallback( keys=[self.params["caption_tokens_field"]], func=lambda dict: splitter_target.decode( dict[self.params["caption_tokens_field"]], ["target_len"])[0]) } decoder = TFSEquenceExampleDecoder(context_keys_to_features, sequence_keys_to_features, items_to_handlers) dataset = tf.contrib.slim.dataset.Dataset( data_sources=data_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 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 testDecodeExampleWithBackupHandlerLookup(self): example1 = example_pb2.Example(features=feature_pb2.Features( feature={ 'image/object/class/text': self._BytesFeature(np.array(['cat', 'dog', 'guinea pig'])), 'image/object/class/label': self._EncodedInt64Feature(np.array([42, 10, 900])) })) example2 = example_pb2.Example(features=feature_pb2.Features( feature={ 'image/object/class/text': self._BytesFeature(np.array(['cat', 'dog', 'guinea pig'])), })) example3 = example_pb2.Example(features=feature_pb2.Features( feature={ 'image/object/class/label': self._EncodedInt64Feature(np.array([42, 10, 901])) })) # 'dog' -> 0, 'guinea pig' -> 1, 'cat' -> 2 table = lookup_ops.index_table_from_tensor( constant_op.constant(['dog', 'guinea pig', 'cat'])) keys_to_features = { 'image/object/class/text': parsing_ops.VarLenFeature(dtypes.string), 'image/object/class/label': parsing_ops.VarLenFeature(dtypes.int64), } backup_handler = tfexample_decoder.BackupHandler( handler=tfexample_decoder.Tensor('image/object/class/label'), backup=tfexample_decoder.LookupTensor('image/object/class/text', table)) items_to_handlers = { 'labels': backup_handler, } decoder = tfexample_decoder.TFExampleDecoder(keys_to_features, items_to_handlers) obtained_class_ids_each_example = [] with self.test_session() as sess: sess.run(lookup_ops.tables_initializer()) for example in [example1, example2, example3]: serialized_example = array_ops.reshape( example.SerializeToString(), shape=[]) obtained_class_ids_each_example.append( decoder.decode(serialized_example)[0].eval()) self.assertAllClose([42, 10, 900], obtained_class_ids_each_example[0]) self.assertAllClose([2, 0, 1], obtained_class_ids_each_example[1]) self.assertAllClose([42, 10, 901], obtained_class_ids_each_example[2])
def test_decode_example_with_iInt64_tensor(self): np_array = np.random.randint(1, 10, size=(2, 3, 1)) example = example_pb2.Example(features=feature_pb2.Features(feature={ 'array': self._encode_int64_feature(np_array), })) serialized_example = example.SerializeToString() with self.test_session(): serialized_example = array_ops.reshape(serialized_example, shape=[]) keys_to_features = { 'array': parsing_ops.FixedLenFeature(np_array.shape, dtypes.int64) } items_to_handlers = {'array': tfexample_decoder.Tensor('array'), } decoder = TFExampleDecoder(keys_to_features, items_to_handlers) [tf_array] = decoder.decode(serialized_example, ['array']) self.assertAllEqual(tf_array.eval(), np_array)
def test_decode_example_with_var_len_tensor(self): np_array = np.array([[[1], [2], [3]], [[4], [5], [6]]]) example = example_pb2.Example(features=feature_pb2.Features(feature={ 'labels': self._encode_int64_feature(np_array), })) serialized_example = example.SerializeToString() with self.test_session(): serialized_example = array_ops.reshape(serialized_example, shape=[]) keys_to_features = { 'labels': parsing_ops.VarLenFeature(dtype=dtypes.int64), } items_to_handlers = {'labels': tfexample_decoder.Tensor('labels'), } decoder = TFExampleDecoder(keys_to_features, items_to_handlers) [tf_labels] = decoder.decode(serialized_example, ['labels']) labels = tf_labels.eval() self.assertAllEqual(labels, np_array.flatten())
def testDecodeExampleWithFloatTensor(self): np_array = np.random.rand(2, 3, 1).astype('f') example = example_pb2.Example( features=feature_pb2.Features(feature={ 'array': self._EncodedFloatFeature(np_array), })) serialized_example = example.SerializeToString() with self.cached_session(): serialized_example = array_ops.reshape(serialized_example, shape=[]) keys_to_features = { 'array': parsing_ops.FixedLenFeature(np_array.shape, dtypes.float32) } items_to_handlers = { 'array': tfexample_decoder.Tensor('array'), } decoder = tfexample_decoder.TFExampleDecoder(keys_to_features, items_to_handlers) [tf_array] = decoder.decode(serialized_example, ['array']) self.assertAllEqual(tf_array.eval(), np_array)
def __init__(self, data_sources, has_mask, labels, context_window_size, observation_codes, intervention_codes): """Creates a dataset for clinical time series dense feature lab data. Args: data_sources: A list of files/patterns for the slim Dataset. has_mask: Whether the dataset has obs_mask and true_length_hr feature. labels: A list of labels in string, corresponding to labels in ModelConfig. context_window_size: size of the context window, i.e, the length of the time series. observation_codes: A list of features corresponding to the observation time series data. intervention_codes: A list of features corresponding to the intervention time series data. Returns: A slim dataset with proper reader and decoders. """ keys_to_features = {} items_to_handlers = {} keys_to_features['context_window_size'] = tf.FixedLenFeature( [], dtype=tf.int64, default_value=0) items_to_handlers['context_window_size'] = tfexample_decoder.Tensor( 'context_window_size', default_value=0) keys_to_features['context_window_start_time_sec'] = tf.FixedLenFeature( [], dtype=tf.int64, default_value=0) items_to_handlers[ 'context_window_start_time_sec'] = tfexample_decoder.Tensor( 'context_window_start_time_sec', default_value=0) keys_to_features['trigger_time_sec'] = tf.FixedLenFeature( [], dtype=tf.int64, default_value=0) items_to_handlers['trigger_time_sec'] = tfexample_decoder.Tensor( 'trigger_time_sec', default_value=0) if has_mask: keys_to_features['true_length_hr'] = tf.FixedLenFeature( [], dtype=tf.int64, default_value=0) items_to_handlers['true_length_hr'] = tfexample_decoder.Tensor( 'true_length_hr', default_value=0) tf.logging.info('Labels are:') for label in labels: tf.logging.info(label) keys_to_features[label[0]] = tf.FixedLenFeature([], dtype=tf.int64, default_value=-1) items_to_handlers[label[0]] = tfexample_decoder.Tensor(label[0]) # This label is for a survival analysis event. if label[1]: tf.logging.info(label[0] + '.time_of_event') keys_to_features[label[0] + '.time_of_event'] = tf.FixedLenFeature( [], dtype=tf.int64, default_value=0) items_to_handlers[label[0] + '.time_of_event'] = tfexample_decoder.Tensor( label[0] + '.time_of_event') tf.logging.info('Features are:') for observation in observation_codes: tf.logging.info(observation) keys_to_features[observation] = tf.FixedLenFeature( shape=[context_window_size], dtype=tf.float32) items_to_handlers[observation] = tfexample_decoder.Tensor( observation, default_value=-1) if has_mask: observation = strip_raw_feature(observation) keys_to_features[observation + '_mask'] = tf.FixedLenFeature( shape=[context_window_size], dtype=tf.float32) items_to_handlers[observation + '_mask'] = tfexample_decoder.Tensor( observation + '_mask', default_value=0) for intervention in intervention_codes: tf.logging.info(intervention) keys_to_features[intervention] = tf.FixedLenFeature( shape=[context_window_size], dtype=tf.float32) items_to_handlers[intervention] = tfexample_decoder.Tensor( intervention, default_value=-1) if has_mask: intervention = strip_raw_feature(intervention) keys_to_features[intervention + '_mask'] = tf.FixedLenFeature( shape=[context_window_size], dtype=tf.float32) items_to_handlers[intervention + '_mask'] = tfexample_decoder.Tensor( intervention + '_mask', default_value=0) decoder = tfexample_decoder.TFExampleDecoder(keys_to_features, items_to_handlers) super(ClinicalSeriesDataset, self).__init__(data_sources=data_sources, reader=tf.compat.v1.TFRecordReader, decoder=decoder, num_samples=None, items_to_descriptions={})
def _create_tfrecord_dataset(config): """Create tfrecord dataset for DatasetDataProvider. Args: config: an instance of AdsExample proto. Returns: dataset: a slim.data.dataset.Dataset instance. """ def _handle_frame_features_wrapper(keys_to_tensors): return _handle_frame_features(keys_to_tensors, 'video/features', config.feature_dims) def _handle_climax_features_wrapper(keys_to_tensors): return _handle_frame_features(keys_to_tensors, 'video/climax_features', 1) def _handle_climax_predictions_wrapper(keys_to_tensors): return _handle_frame_features(keys_to_tensors, 'video/climax_predictions', 1) def _handle_common_object_features_wrapper(keys_to_tensors): return _handle_frame_features(keys_to_tensors, 'video/common_object_features', config.common_object_feature_dims) def _handle_place_features_wrapper(keys_to_tensors): return _handle_frame_features(keys_to_tensors, 'video/place_features', config.place_feature_dims) def _handle_emotic_features_wrapper(keys_to_tensors): return _handle_frame_features(keys_to_tensors, 'video/emotic_features', config.emotic_feature_dims) def _handle_affectnet_features_wrapper(keys_to_tensors): return _handle_frame_features(keys_to_tensors, 'video/affectnet_features', config.affectnet_feature_dims) def _handle_shot_boundary_features_wrapper(keys_to_tensors): return _handle_frame_features(keys_to_tensors, 'video/shot_boundary_features', config.shot_boundary_feature_dims) def _handle_optical_flow_features_wrapper(keys_to_tensors): return _handle_frame_features(keys_to_tensors, 'video/optical_flow_features', config.optical_flow_feature_dims) def _handle_audio_features_wrapper(keys_to_tensors): return _handle_frame_features(keys_to_tensors, 'video/audio_features', config.audio_feature_dims) item_handler_frame_features = tfexample_decoder.ItemHandlerCallback( keys=['video/n_frames', 'video/features'], func=_handle_frame_features_wrapper) item_handler_climax_features = tfexample_decoder.ItemHandlerCallback( keys=['video/n_frames', 'video/climax_features'], func=_handle_climax_features_wrapper) item_handler_climax_predictions = tfexample_decoder.ItemHandlerCallback( keys=['video/n_frames', 'video/climax_predictions'], func=_handle_climax_predictions_wrapper) item_handler_common_object_features = tfexample_decoder.ItemHandlerCallback( keys=['video/n_frames', 'video/common_object_features'], func=_handle_common_object_features_wrapper) item_handler_place_features = tfexample_decoder.ItemHandlerCallback( keys=['video/n_frames', 'video/place_features'], func=_handle_place_features_wrapper) item_handler_emotic_features = tfexample_decoder.ItemHandlerCallback( keys=['video/n_frames', 'video/emotic_features'], func=_handle_emotic_features_wrapper) item_handler_affectnet_features = tfexample_decoder.ItemHandlerCallback( keys=['video/n_frames', 'video/affectnet_features'], func=_handle_affectnet_features_wrapper) item_handler_shot_boundary_features = tfexample_decoder.ItemHandlerCallback( keys=['video/n_frames', 'video/shot_boundary_features'], func=_handle_shot_boundary_features_wrapper) item_handler_optical_flow_features = tfexample_decoder.ItemHandlerCallback( keys=['video/n_frames', 'video/optical_flow_features'], func=_handle_optical_flow_features_wrapper) item_handler_audio_features = tfexample_decoder.ItemHandlerCallback( keys=['video/n_frames', 'video/audio_features'], func=_handle_audio_features_wrapper) keys_to_features = { 'video/source_id': tf.FixedLenFeature(shape=(), dtype=tf.string, default_value=''), 'video/n_frames': tf.FixedLenFeature((), tf.int64, default_value=0), 'video/features': tf.VarLenFeature(tf.float32), 'video/climax_features': tf.VarLenFeature(tf.float32), 'video/climax_predictions': tf.VarLenFeature(tf.float32), 'video/common_object_features': tf.VarLenFeature(tf.float32), 'video/place_features': tf.VarLenFeature(tf.float32), 'video/emotic_features': tf.VarLenFeature(tf.float32), 'video/affectnet_features': tf.VarLenFeature(tf.float32), 'video/shot_boundary_features': tf.VarLenFeature(tf.float32), 'video/optical_flow_features': tf.VarLenFeature(tf.float32), 'video/audio_features': tf.VarLenFeature(tf.float32), 'anno/topic': tf.FixedLenFeature((), tf.int64), 'anno/sentiment': tf.FixedLenFeature((), tf.int64), 'anno/sentiment_list': tf.FixedLenFeature([config.sentiment_num_classes], tf.float32), } items_to_handlers = { 'video_id': tfexample_decoder.Tensor('video/source_id'), 'n_frames': tfexample_decoder.Tensor('video/n_frames'), 'topic': tfexample_decoder.Tensor('anno/topic'), 'sentiment': tfexample_decoder.Tensor('anno/sentiment'), 'frame_features': item_handler_frame_features, 'climax_features': item_handler_climax_features, 'climax_predictions': item_handler_climax_predictions, 'common_object_features': item_handler_common_object_features, 'place_features': item_handler_place_features, 'emotic_features': item_handler_emotic_features, 'affectnet_features': item_handler_affectnet_features, 'shot_boundary_features': item_handler_shot_boundary_features, 'optical_flow_features': item_handler_optical_flow_features, 'audio_features': item_handler_audio_features, 'sentiment_list': tfexample_decoder.Tensor('anno/sentiment_list'), } #if config.use_sent_list: # keys_to_features['anno/sentiment_list'] = tf.FixedLenFeature([config.sentiment_num_classes], tf.float32), # items_to_handlers['sentiment_list'] = tfexample_decoder.Tensor('anno/sentiment_list') decoder = tfexample_decoder.TFExampleDecoder(keys_to_features, items_to_handlers) input_paths = [ config.input_path[i] for i in xrange(len(config.input_path)) ] return dataset.Dataset(data_sources=input_paths, reader=tf.TFRecordReader, decoder=decoder, num_samples=config.num_examples, items_to_descriptions=None)
def get_split(split_name='train', split_type="iid", dataset_dir=None, image_length=64, num_classes_per_attribute=None): """Gets a dataset tuple with instructions for reading 2D shapes data. Args: split_name: A train/test split name. split_type: str, type of split being loaded "iid" or "comp" 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 split_type is not "iid": raise ValueError("Only IID split available for CelebA.") if num_classes_per_attribute is None: num_classes_per_attribute = _NUM_CLASSES_PER_ATTRIBUTE if dataset_dir is None or dataset_dir == '': dataset_dir = _DATASET_DIR # Load attribute label map file. label_map_json = os.path.join(dataset_dir, 'attribute_label_map.json') file_pattern = os.path.join(dataset_dir, _FILE_PATTERN % split_name) tf.logging.info('Loading from %s file.' % (file_pattern)) keys_to_features = { 'image/encoded': tf.FixedLenFeature((), tf.string, default_value=''), 'image/format': tf.FixedLenFeature((), tf.string, default_value='raw'), 'image/labels': tf.FixedLenFeature([len(num_classes_per_attribute)], tf.int64), } # TODO(vrama): See # https://github.com/tensorflow/tensorflow/blob/master/tensorflow/contrib/slim/python/slim/data/tfexample_decoder.py#L270 # For where changes would need to be made to preprocess the images which # get loaded. items_to_handlers = { 'image': ImageDecodeProcess(shape=[218, 178, 3], image_length=64), 'labels': tfexample_decoder.Tensor('image/labels'), } decoder = tfexample_decoder.TFExampleDecoder(keys_to_features, items_to_handlers) metadata = { 'num_classes_per_attribute': num_classes_per_attribute, 'split_type': _SPLIT_TYPE, 'label_map_json': label_map_json, } 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