def test_make_tfrecord_options_with_bad_inputs(self, filenames): with self.assertRaisesRegexp( ValueError, 'Incorrect value: {}. Filenames need to be all of the same type: ' 'either all with .gz or all without .gz'.format( ','.join(filenames))): io.make_tfrecord_options(filenames)
def assertDataSetExamplesMatchExpected(self, dataset, expected_dataset): with tf.Session() as sess: provider = slim.dataset_data_provider.DatasetDataProvider( expected_dataset.get_slim_dataset(), shuffle=False, reader_kwargs={ 'options': io_utils.make_tfrecord_options(expected_dataset.source) }) sess.run(tf.global_variables_initializer()) coord = tf.train.Coordinator() threads = tf.train.start_queue_runners(coord=coord, sess=sess) image, label, locus = provider.get(['image', 'label', 'locus']) seen = [ sess.run([image, label, locus])[2] for _ in range(expected_dataset.num_examples) ] coord.request_stop() coord.join(threads) expected_loci = [ example.features.feature['locus'].bytes_list.value[0] for example in io_utils.read_tfrecords(expected_dataset.source) ] self.assertEqual(len(expected_loci), expected_dataset.num_examples) self.assertEqual(expected_loci, seen) # Note that this expected shape comes from the golden dataset. If the data # is remade in the future, the values might need to be modified accordingly. self.assertEqual([100, 221, 7], expected_dataset.tensor_shape)
def make_training_batches(dataset, model, batch_size): """Provides batches of pileup images from this dataset. Creates a DataSetProvider for dataset, extracts image, label, and truth_variant from it, preprocesses each image with model.preprocess_image() and finally batches these up. Args: dataset: a slim DataSet we want to turn into batches. Must provide data items "image", "label", and "truth_variant". model: a DeepVariantModel to use for preprocessing each image before batching. batch_size: the number of images in each batch. Returns: images: 4-D float Tensor of a batch of images with shape (batch_size, height, width, 3). labels: a 1-D integer Tensor shape (batch_size,) containing the labels for each image, in the same order. encoded_truth_variants: Tensor of strings with shape (batch_size,). Each element of this tensor is a byte-encoded learning.genomics.v1.Variant protobuf in the same order as images and one_hot_labels. """ data_provider = slim.dataset_data_provider.DatasetDataProvider( dataset, common_queue_capacity=2 * batch_size, common_queue_min=batch_size, reader_kwargs={ 'options': io_utils.make_tfrecord_options(dataset.data_sources) }) # Load the data. image, label, truth_variant = data_provider.get( ['image', 'label', 'truth_variant']) image = model.preprocess_image(image) return tf.train.shuffle_batch( [image, label, truth_variant], batch_size=batch_size, num_threads=4, capacity=5000, # redacted min_after_dequeue=min(1000, dataset.num_samples))
def prepare_inputs(source_path, model, batch_size, num_readers=None): """Prepares image and encoded_variant ops. Reads image / encoded_variant tuples from source_path, extracting the image and encoded_variant tensors from source_path. The image is decoded from its png encoding and preprocessed with model.preprocess_image as well. Every example in source_path is read once (num_epoch=1). Args: source_path: Path to a TFRecord file containing deepvariant tf.Example protos. model: A DeepVariantModel whose preprocess_image function will be used on image. batch_size: int > 0. Size of batches to use during inference. num_readers: int > 0 or None. Number of parallel readers to use to read examples from source_path. If None, uses FLAGS.num_readers instead. Returns: A tuple of (image, encoded_variant, encoded_alt_allele_indices) TF ops. Image is a [height, width, channel] tensor. encoded_variants is a tf.string tensor containing a serialized Variant proto describing the variant call associated with image. encoded_alt_allele_indices is a tf.string tensor containing a serialized CallVariantsOutput.AltAlleleIndices proto containing the alternate alleles indices used as "alt" when constructing the image. """ if not num_readers: num_readers = FLAGS.num_readers tensor_shape = tf_utils.get_shape_from_examples_path(source_path) def _parse_single_example(serialized_example): """Parses serialized example into a dictionary of de-serialized features.""" features = tf.parse_single_example( serialized_example, features={ 'image/encoded': tf.FixedLenFeature([], tf.string), 'variant/encoded': tf.FixedLenFeature([], tf.string), # deepvariant_pb2.CallVariantsOutput.AltAlleleIndices 'alt_allele_indices/encoded': tf.FixedLenFeature([], tf.string), }) return features with tf.name_scope('input'): def _preprocess_image(features): """Preprocess images (decode, reshape, and apply model-specific steps).""" image = features['image/encoded'] # Bypassing the reshaping and preprocessing if there is no tensor_shape. # Currently that could happen when the input file is empty. if tensor_shape: image = tf.reshape(tf.decode_raw(image, tf.uint8), tensor_shape) image = model.preprocess_image(image) features['image/encoded'] = image return features files = tf.gfile.Glob( io_utils.NormalizeToShardedFilePattern(source_path)) reader_options = io_utils.make_tfrecord_options(files) if reader_options.compression_type == ( tf.python_io.TFRecordCompressionType.GZIP): compression_type = 'GZIP' else: compression_type = None dataset = tf.data.TFRecordDataset(files, compression_type=compression_type) dataset = dataset.map(_parse_single_example, num_parallel_calls=FLAGS.num_readers) dataset = dataset.map(_preprocess_image, num_parallel_calls=FLAGS.num_readers) dataset = dataset.prefetch(10 * batch_size) dataset = dataset.batch(batch_size) iterator = dataset.make_one_shot_iterator() features = iterator.get_next() return (features['image/encoded'], features['variant/encoded'], features['alt_allele_indices/encoded'])
def test_make_tfrecord_options(self, filenames, expected_compression_type): compression_type = tf.python_io.TFRecordOptions.get_compression_type_string( io.make_tfrecord_options(filenames)) self.assertEqual(compression_type, expected_compression_type)