def train(self, sess, audio_processor, test_set, train_set, steps_per_checkpoint, checkpoint_dir, max_epoch=None): # Create a queue for each dataset and a coordinator # Shuffle queue for the train set, but we don't shuffle too much in order to keep the benefit from # having homogeneous sizes in a given batch (files are ordered by size ascending) capacity = min(self.batch_size * 10, len(train_set)) min_after_dequeue = min(self.batch_size * 7, len(train_set) - self.batch_size) train_queue = tf.RandomShuffleQueue( capacity, min_after_dequeue, [tf.int32, tf.int32, tf.int32, tf.int32], shapes=[[self.max_input_seq_length, self.input_dim], [], [self.max_target_seq_length], []]) # Simple FIFO queue for the test set because we don't care to test always in the same order capacity = min(self.batch_size * 10, len(test_set)) test_queue = tf.FIFOQueue( capacity, [tf.int32, tf.int32, tf.int32, tf.int32], shapes=[[self.max_input_seq_length, self.input_dim], [], [self.max_target_seq_length], []]) coord = tf.train.Coordinator() # Define the enqueue operation for training data train_mfcc_input = tf.placeholder( tf.int32, shape=[self.max_input_seq_length, self.input_dim]) train_mfcc_input_length = tf.placeholder(tf.int32, shape=[]) train_label = tf.placeholder(tf.int32, shape=[self.max_target_seq_length]) train_label_length = tf.placeholder(tf.int32, shape=[]) train_enqueue_op = train_queue.enqueue([ train_mfcc_input, train_mfcc_input_length, train_label, train_label_length ]) train_dequeue_op = train_queue.dequeue_many(self.batch_size) # Define the enqueue operation for test data test_mfcc_input = tf.placeholder( tf.int32, shape=[self.max_input_seq_length, self.input_dim]) test_mfcc_input_length = tf.placeholder(tf.int32, shape=[]) test_label = tf.placeholder(tf.int32, shape=[self.max_target_seq_length]) test_label_length = tf.placeholder(tf.int32, shape=[]) test_enqueue_op = test_queue.enqueue([ test_mfcc_input, test_mfcc_input_length, test_label, test_label_length ]) test_dequeue_op = test_queue.dequeue_many(self.batch_size) # Calculate approximate position for learning batch, allow to keep consistency between multiple iterations # of the same training job (will default to 0 if it is the first launch because global_step will be 0) start_from = self.global_step.eval() * self.batch_size logging.info("Start training from file number : %d", start_from) # Create the threads thread_local_data = threading.local() threads = [ threading.Thread(name="train_enqueue", target=self.enqueue_data, args=(coord, sess, audio_processor, thread_local_data, train_enqueue_op, train_set, train_mfcc_input, train_mfcc_input_length, train_label, train_label_length, start_from)), threading.Thread( name="test_enqueue", target=self.enqueue_data, args=(coord, sess, audio_processor, thread_local_data, test_enqueue_op, test_set, test_mfcc_input, test_mfcc_input_length, test_label, test_label_length)) ] for t in threads: t.start() previous_loss = 0 no_improvement_since = 0 step_time, mean_loss = 0.0, 0.0 current_step = 1 # Main training loop while True: if coord.should_stop(): break start_time = time.time() input_feat_vecs, mfcc_lengths_batch, label_values_batch, label_indices_batch =\ self.dequeue_data(sess, train_dequeue_op) step_loss = self.step(sess, input_feat_vecs, mfcc_lengths_batch, label_values_batch, label_indices_batch, forward_only=False) # Decrease learning rate if no improvement was seen over last 6 steps if step_loss >= previous_loss: no_improvement_since += 1 if no_improvement_since == 6: sess.run(self.learning_rate_decay_op) no_improvement_since = 0 if self.learning_rate.eval() < 1e-7: # End learning process break else: no_improvement_since = 0 previous_loss = step_loss # Step result logging.info("Step %d with loss %.4f", current_step, step_loss) step_time += (time.time() - start_time) / steps_per_checkpoint mean_loss += step_loss / steps_per_checkpoint # Check if we are at a checkpoint if current_step % steps_per_checkpoint == 0: logging.info( "Global step %d / learning rate %.4f / step-time %.2f / loss %.2f", self.global_step.eval(), self.learning_rate.eval(), step_time, mean_loss) num_test_batches = self.get_num_batches(test_set) self.run_checkpoint(sess, checkpoint_dir, num_test_batches, test_dequeue_op) step_time, mean_loss = 0.0, 0.0 current_step += 1 if (max_epoch is not None) and (current_step > max_epoch): # We have reached the maximum allowed, we should exit at the end of this run break # Ask the threads to stop. coord.request_stop() # And wait for them to actually do it. coord.join(threads)
def prefetch_input_data(reader, file_pattern, is_training, batch_size, values_per_shard, input_queue_capacity_factor=16, num_reader_threads=1, shard_queue_name="filename_queue", value_queue_name="input_queue"): """Prefetches string values from disk into an input queue. In training the capacity of the queue is important because a larger queue means better mixing of training examples between shards. The minimum number of values kept in the queue is values_per_shard * input_queue_capacity_factor, where input_queue_memory factor should be chosen to trade-off better mixing with memory usage. Args: reader: Instance of tf.ReaderBase. file_pattern: Comma-separated list of file patterns (e.g. /tmp/train_data-?????-of-00100). is_training: Boolean; whether prefetching for training or eval. batch_size: Model batch size used to determine queue capacity. values_per_shard: Approximate number of values per shard. input_queue_capacity_factor: Minimum number of values to keep in the queue in multiples of values_per_shard. See comments above. num_reader_threads: Number of reader threads to fill the queue. shard_queue_name: Name for the shards filename queue. value_queue_name: Name for the values input queue. Returns: A Queue containing prefetched string values. """ data_files = [] for pattern in file_pattern.split(","): data_files.extend(tf.gfile.Glob(pattern)) if not data_files: tf.logging.fatal("Found no input files matching %s", file_pattern) else: tf.logging.info("Prefetching values from %d files matching %s", len(data_files), file_pattern) if is_training: filename_queue = tf.train.string_input_producer(data_files, shuffle=True, capacity=16, name=shard_queue_name) min_queue_examples = values_per_shard * input_queue_capacity_factor capacity = min_queue_examples + 100 * batch_size values_queue = tf.RandomShuffleQueue( capacity=capacity, min_after_dequeue=min_queue_examples, dtypes=[tf.string], name="random_" + value_queue_name) else: filename_queue = tf.train.string_input_producer(data_files, shuffle=False, capacity=1, name=shard_queue_name) capacity = values_per_shard + 3 * batch_size values_queue = tf.FIFOQueue(capacity=capacity, dtypes=[tf.string], name="fifo_" + value_queue_name) enqueue_ops = [] for _ in range(num_reader_threads): _, value = reader.read(filename_queue) enqueue_ops.append(values_queue.enqueue([value])) tf.train.queue_runner.add_queue_runner( tf.train.queue_runner.QueueRunner(values_queue, enqueue_ops)) tf.summary.scalar( "queue/%s/fraction_of_%d_full" % (values_queue.name, capacity), tf.cast(values_queue.size(), tf.float32) * (1. / capacity)) return values_queue
from __future__ import print_function import tensorflow as tf sess = tf.InteractiveSession() gen_random_normal = tf.random_normal(shape=()) queue = tf.RandomShuffleQueue(capacity=100, dtypes=[tf.float32], min_after_dequeue=1) enqueue_op = queue.enqueue(gen_random_normal) qr = tf.train.QueueRunner(queue, [enqueue_op] * 4) coord = tf.train.Coordinator() enqueue_threads = qr.create_threads(sess, coord=coord, start=True) coord.request_stop() coord.join(enqueue_threads)
def build_input(dataset, data_path, batch_size, mode): """Build CIFAR image and labels. Args: dataset: Either 'cifar10' or 'cifar100'. data_path: Filename for data. batch_size: Input batch size. mode: Either 'train' or 'eval'. Returns: images: Batches of images. [batch_size, image_size, image_size, 3] labels: Batches of labels. [batch_size, num_classes] Raises: ValueError: when the specified dataset is not supported. """ image_size = 32 if dataset == 'cifar10': label_bytes = 1 label_offset = 0 num_classes = 10 elif dataset == 'cifar100': label_bytes = 1 label_offset = 1 num_classes = 100 else: raise ValueError('Not supported dataset %s', dataset) depth = 3 image_bytes = image_size * image_size * depth record_bytes = label_bytes + label_offset + image_bytes data_files = tf.gfile.Glob(data_path) file_queue = tf.train.string_input_producer(data_files, shuffle=True) # Read examples from files in the filename queue. reader = tf.FixedLengthRecordReader(record_bytes=record_bytes) _, value = reader.read(file_queue) # Convert these examples to dense labels and processed images. record = tf.reshape(tf.decode_raw(value, tf.uint8), [record_bytes]) label = tf.cast(tf.slice(record, [label_offset], [label_bytes]), tf.int32) # Convert from string to [depth * height * width] to [depth, height, width]. depth_major = tf.reshape( tf.slice(record, [label_offset + label_bytes], [image_bytes]), [depth, image_size, image_size]) # Convert from [depth, height, width] to [height, width, depth]. image = tf.cast(tf.transpose(depth_major, [1, 2, 0]), tf.float32) if mode == 'train': image = tf.image.resize_image_with_crop_or_pad(image, image_size + 4, image_size + 4) image = tf.random_crop(image, [image_size, image_size, 3]) image = tf.image.random_flip_left_right(image) # Brightness/saturation/constrast provides small gains .2%~.5% on cifar. # image = tf.image.random_brightness(image, max_delta=63. / 255.) # image = tf.image.random_saturation(image, lower=0.5, upper=1.5) # image = tf.image.random_contrast(image, lower=0.2, upper=1.8) image = tf.image.per_image_standardization(image) example_queue = tf.RandomShuffleQueue( capacity=16 * batch_size, min_after_dequeue=8 * batch_size, dtypes=[tf.float32, tf.int32], shapes=[[image_size, image_size, depth], [1]]) num_threads = 16 else: image = tf.image.resize_image_with_crop_or_pad(image, image_size, image_size) image = tf.image.per_image_standardization(image) example_queue = tf.FIFOQueue(3 * batch_size, dtypes=[tf.float32, tf.int32], shapes=[[image_size, image_size, depth], [1]]) num_threads = 1 example_enqueue_op = example_queue.enqueue([image, label]) tf.train.add_queue_runner( tf.train.queue_runner.QueueRunner(example_queue, [example_enqueue_op] * num_threads)) # Read 'batch' labels + images from the example queue. images, labels = example_queue.dequeue_many(batch_size) labels = tf.reshape(labels, [batch_size, 1]) indices = tf.reshape(tf.range(0, batch_size, 1), [batch_size, 1]) labels = tf.sparse_to_dense(tf.concat(values=[indices, labels], axis=1), [batch_size, num_classes], 1.0, 0.0) assert len(images.get_shape()) == 4 assert images.get_shape()[0] == batch_size assert images.get_shape()[-1] == 3 assert len(labels.get_shape()) == 2 assert labels.get_shape()[0] == batch_size assert labels.get_shape()[1] == num_classes # Display the training images in the visualizer. tf.summary.image('images', images) return images, labels
def __init__(self, dataset1, dataset2, shuffle=True, num_epochs=None, common_queue_capacity=4096, common_queue_min=1024, seed=None): if seed is None: seed = np.random.randint(10e8) _, data_source = parallel_reader.parallel_read( dataset1.data_sources, reader_class=dataset1.reader, num_epochs=num_epochs, num_readers=1, shuffle=False, capacity=common_queue_capacity, min_after_dequeue=common_queue_min, seed=seed) data_target = "" if dataset2 is not None: _, data_target = parallel_reader.parallel_read( dataset2.data_sources, reader_class=dataset2.reader, num_epochs=num_epochs, num_readers=1, shuffle=False, capacity=common_queue_capacity, min_after_dequeue=common_queue_min, seed=seed) # Optionally shuffle the data if shuffle: shuffle_queue = tf.RandomShuffleQueue( capacity=common_queue_capacity, min_after_dequeue=common_queue_min, dtypes=[tf.string, tf.string], seed=seed) enqueue_ops = [] enqueue_ops.append( shuffle_queue.enqueue([data_source, data_target])) tf.train.add_queue_runner( tf.train.QueueRunner(shuffle_queue, enqueue_ops)) data_source, data_target = shuffle_queue.dequeue() # Decode source items items = dataset1.decoder.list_items() tensors = dataset1.decoder.decode(data_source, items) if dataset2 is not None: # Decode target items items2 = dataset2.decoder.list_items() tensors2 = dataset2.decoder.decode(data_target, items2) # Merge items and results items = items + items2 tensors = tensors + tensors2 super(ParallelDataProvider, self).__init__(items_to_tensors=dict(zip(items, tensors)), num_samples=dataset1.num_samples)
def batch_inputs(data_dir, batch_size, image_size, train, num_preprocess_threads=4, num_readers=1, input_queue_memory_factor=16): with tf.name_scope('batch_processing'): if train: files = data_files(data_dir, 'train') filename_queue = tf.train.string_input_producer(files, shuffle=True, capacity=16) else: files = data_files(data_dir, 'validation') filename_queue = tf.train.string_input_producer(files, shuffle=False, capacity=1) if num_preprocess_threads % 4: raise ValueError('Please make num_preprocess_threads a multiple ' 'of 4 (%d % 4 != 0).', num_preprocess_threads) if num_readers < 1: raise ValueError('Please make num_readers at least 1') # Approximate number of examples per shard. examples_per_shard = 1024 # Size the random shuffle queue to balance between good global # mixing (more examples) and memory use (fewer examples). # 1 image uses 299*299*3*4 bytes = 1MB # The default input_queue_memory_factor is 16 implying a shuffling queue # size: examples_per_shard * 16 * 1MB = 17.6GB min_queue_examples = examples_per_shard * input_queue_memory_factor if train: examples_queue = tf.RandomShuffleQueue( capacity=min_queue_examples + 3 * batch_size, min_after_dequeue=min_queue_examples, dtypes=[tf.string]) else: examples_queue = tf.FIFOQueue( capacity=examples_per_shard + 3 * batch_size, dtypes=[tf.string]) # Create multiple readers to populate the queue of examples. if num_readers > 1: enqueue_ops = [] for _ in range(num_readers): reader = tf.TFRecordReader() _, value = reader.read(filename_queue) enqueue_ops.append(examples_queue.enqueue([value])) tf.train.queue_runner.add_queue_runner( tf.train.queue_runner.QueueRunner(examples_queue, enqueue_ops)) example_serialized = examples_queue.dequeue() else: reader = tf.TFRecordReader() _, example_serialized = reader.read(filename_queue) images_labels_fnames = [] for thread_id in range(num_preprocess_threads): # Parse a serialized Example proto to extract the image and metadata. image_buffer, label_index, fname = parse_example_proto(example_serialized) image = image_preprocessing(image_buffer, image_size, train, thread_id) images_labels_fnames.append([image, label_index, fname]) images, label_index_batch, fnames = tf.train.batch_join( images_labels_fnames, batch_size=batch_size, capacity=2 * num_preprocess_threads * batch_size) images = tf.cast(images, tf.float32) images = tf.reshape(images, shape=[batch_size, image_size, image_size, 3]) # Display the training images in the visualizer. tf.summary.image('images', images, 20) return images, tf.reshape(label_index_batch, [batch_size]), fnames
#============================================================================== #create some threads manipulate queues #============================================================================== import tensorflow as tf import numpy as np seed = 10 batchSize = 1 threadNums = 10 #get a random sample with shape(3, ) sample = tf.random_normal([5], seed=seed, dtype=tf.float32) queue = tf.RandomShuffleQueue(capacity=30, min_after_dequeue=1, dtypes=[tf.float32] * 3) #queue = tf.FIFOQueue(100, [tf.float32] * 2) initQueue = queue.enqueue_many([sample * i for i in range(1, 11)]) x = queue.dequeue() dequeueOp = queue.dequeue(2) #out, each batchSize sample #create a queueRunner with some threads enqueue #enqueueRunners = tf.train.QueueRunner(queue, enqueue_ops=[enqueueOp]*threadNums) #begin session sess = tf.Session() #coord = tf.train.Coordinator() #threads = tf.train.start_queue_runners(sess=sess, coord=coord)
def train(self): flags = self.FLAGS block_shape = self.block_shape record_dir = self.record_dir record_dir_test = self.record_dir_test batch_size_train = self.batch_size_train batch_size_test = self.batch_size_test test_step = self.test_step LEARNING_RATE_BASE = flags.training_rate_base LEARNING_RATE_DECAY = flags.training_rate_decay X = tf.placeholder(dtype=tf.float32, shape=[ batch_size_train, block_shape[0], block_shape[1], block_shape[2] ]) training = tf.placeholder(tf.bool) with tf.variable_scope('generator'): airway_pred, airway_sig, artery_pred, artery_sig = self.Dense_Net( X, training, flags.batch_size_train, flags.accept_threshold) # lung_pred = tf.reshape(lung_pred,[batch_size_train,block_shape[0],block_shape[1],block_shape[2]]) airway_pred = tf.reshape( airway_pred, [batch_size_train, block_shape[0], block_shape[1], block_shape[2]]) artery_pred = tf.reshape( artery_pred, [batch_size_train, block_shape[0], block_shape[1], block_shape[2]]) # binary predict mask # lung_pred_mask = tf.cast((lung_pred>0.01),tf.float32) airway_pred_mask = tf.cast((airway_pred > 0.01), tf.float32) artery_pred_mask = tf.cast((artery_pred > 0.01), tf.float32) # labels # lung_lable = tf.placeholder(dtype=tf.float32,shape=[batch_size_train,block_shape[0],block_shape[1],block_shape[2]]) airway_lable = tf.placeholder(dtype=tf.float32, shape=[ batch_size_train, block_shape[0], block_shape[1], block_shape[2] ]) artery_lable = tf.placeholder(dtype=tf.float32, shape=[ batch_size_train, block_shape[0], block_shape[1], block_shape[2] ]) # discriminator output with tf.variable_scope('discriminator'): XY_real_pair = self.Dis(X, artery_lable, training, flags.batch_size_train) with tf.variable_scope('discriminator', reuse=True): XY_fake_pair = self.Dis(X, artery_sig, training, flags.batch_size_train) # accuracy # lung_acc = 2*tf.reduce_sum(lung_lable*lung_pred_mask)/(tf.reduce_sum(lung_lable+lung_pred_mask)+1e-6) # tf.summary.scalar('lung_acc', lung_acc) airway_acc = 2 * tf.reduce_sum(airway_lable * airway_pred_mask) / ( tf.reduce_sum(airway_lable + airway_pred_mask) + 1e-6) tf.summary.scalar('airway_acc', airway_acc) artery_acc = 2 * tf.reduce_sum(artery_lable * artery_pred_mask) / ( tf.reduce_sum(artery_lable + artery_pred_mask) + 1e-6) tf.summary.scalar('artery_acc', artery_acc) # generator cross entropy loss # w_fore_lung = flags.lung_fore_weight w_fore_airway = flags.airway_fore_weight w_fore_artery = flags.artery_fore_weight # lung loss airway_lable_ = tf.reshape(airway_lable, shape=[batch_size_train, -1]) artery_lable_ = tf.reshape(artery_lable, shape=[batch_size_train, -1]) airway_pred_ = tf.reshape(airway_pred, shape=[batch_size_train, -1]) artery_pred_ = tf.reshape(artery_pred, shape=[batch_size_train, -1]) airway_loss = flags.airway_weight * tf.reduce_mean(-tf.reduce_mean( w_fore_airway * airway_lable_ * tf.log(airway_pred_ + 1e-8), reduction_indices=[1]) - tf.reduce_mean( (1 - w_fore_airway) * (1 - airway_lable_) * tf.log(1 - airway_pred_ + 1e-8), reduction_indices=[1])) tf.summary.scalar('airway_loss_cross_entropy', airway_loss) # predict_mean_lung = tf.reduce_mean(tf.log(1-lung_pred + 1e-8),reduction_indices=[1]) # mask_mean_lung = tf.reduce_mean((1-lung_lable)) # artery loss artery_loss = flags.artery_weight * tf.reduce_mean(-tf.reduce_mean( w_fore_artery * artery_lable_ * tf.log(artery_pred_ + 1e-8), reduction_indices=[1]) - tf.reduce_mean( (1 - w_fore_artery) * (1 - artery_lable_) * tf.log(1 - artery_pred_ + 1e-8), reduction_indices=[1])) tf.summary.scalar('artery_loss_cross_entropy', artery_loss) # predict_mean_artery = tf.reduce_mean(tf.log(1 - artery_pred + 1e-8), reduction_indices=[1]) # mask_mean_artery = tf.reduce_mean((1 - artery_lable)) # generator cross entropy loss ge_loss = airway_loss + artery_loss tf.summary.scalar('generator_cross_entropy_loss', ge_loss) # discriminator and gan loss gan_g_loss = -tf.reduce_mean(XY_fake_pair) gan_d_loss = tf.reduce_mean(XY_fake_pair) - tf.reduce_mean( XY_real_pair) tf.summary.scalar('dis_g_loss', gan_g_loss) tf.summary.scalar('dis_d_loss', gan_d_loss) alpha = tf.random_uniform(shape=[ batch_size_train, block_shape[0] * block_shape[1] * block_shape[2] ], minval=0.0, maxval=1.0) artery_sig_ = tf.reshape(artery_sig, shape=[batch_size_train, -1]) diffenences_ = artery_sig_ - artery_lable_ interpolates = artery_lable_ + alpha * diffenences_ with tf.variable_scope('discriminator', reuse=True): XY_fake_intep = self.Dis(X, interpolates, training, batch_size_train) gradients = tf.gradients(XY_fake_intep, [interpolates])[0] slopes = tf.sqrt( tf.reduce_sum(tf.square(gradients), reduction_indices=[1])) gradient_penalty = tf.reduce_mean((slopes - 1.0)**2) gan_d_loss += 10 * gradient_penalty # total generator loss gan_g_w = 5 ge_w = 100 - gan_g_w total_g_loss = ge_w * ge_loss + gan_g_w * gan_g_loss tf.summary.scalar('total_g_loss', total_g_loss) # set training step and learning rate into tensors to save global_step = tf.Variable(0, trainable=False) learning_rate = tf.maximum( tf.train.exponential_decay(LEARNING_RATE_BASE, global_step, 15000 / flags.batch_size_train, LEARNING_RATE_DECAY, staircase=True), 1e-9) # merge operation for tensorboard summary merge_summary_op = tf.summary.merge_all() # trainer ge_var = [ var for var in tf.trainable_variables() if var.name.startswith('generator') ] dis_var = [ var for var in tf.trainable_variables() if var.name.startswith('discriminator') ] ge_train_op = tf.train.AdamOptimizer(learning_rate=learning_rate, beta1=0.9, beta2=0.999, epsilon=1e-8).minimize( total_g_loss, global_step, ge_var) dis_train_op = tf.train.AdamOptimizer(learning_rate=learning_rate, beta1=0.9, beta2=0.999, epsilon=1e-8).minimize( gan_d_loss, global_step, dis_var) # data part records = ut.get_records(record_dir) records_processor = TF_Records(records, block_shape) single_blocks = records_processor.read_records() queue = tf.RandomShuffleQueue(capacity=8, min_after_dequeue=4, dtypes=( single_blocks['airway'].dtype, single_blocks['artery'].dtype, single_blocks['lung'].dtype, single_blocks['original'].dtype, )) enqueue_op = queue.enqueue(( single_blocks['airway'], single_blocks['artery'], single_blocks['lung'], single_blocks['original'], )) (airway_block, artery_block, lung_block, original_block) = queue.dequeue() qr = tf.train.QueueRunner(queue, [enqueue_op] * 2) # test data part records_test = ut.get_records(record_dir_test) records_processor_test = TF_Records(records_test, block_shape) single_blocks_test = records_processor_test.read_records() queue_test = tf.RandomShuffleQueue( capacity=8, min_after_dequeue=4, dtypes=( single_blocks_test['airway'].dtype, single_blocks_test['artery'].dtype, single_blocks_test['lung'].dtype, single_blocks_test['original'].dtype, )) enqueue_op_test = queue_test.enqueue(( single_blocks_test['airway'], single_blocks_test['artery'], single_blocks_test['lung'], single_blocks_test['original'], )) (airway_block_test, artery_block_test, lung_block_test, original_block_test) = queue_test.dequeue() qr_test = tf.train.QueueRunner(queue, [enqueue_op_test] * 2) saver = tf.train.Saver(max_to_keep=1) config = tf.ConfigProto(allow_soft_placement=True) with tf.Session(config=config) as sess: # load variables if saved before if len(os.listdir(self.train_models_dir)) > 0: print "load saved model" sess.run( tf.group(tf.global_variables_initializer(), tf.local_variables_initializer())) saver.restore(sess, self.train_models_dir + "train_models.ckpt") else: sess.run( tf.group(tf.global_variables_initializer(), tf.local_variables_initializer())) # coord for the reading threads coord = tf.train.Coordinator() enqueue_threads = qr.create_threads(sess, coord=coord, start=True) enqueue_threads_test = qr_test.create_threads(sess, coord=coord, start=True) tf.train.start_queue_runners(sess=sess) summary_writer_test = tf.summary.FileWriter( self.test_sum_dir, sess.graph) summary_writer_train = tf.summary.FileWriter( self.train_sum_dir, sess.graph) # main train loop # for i in range(flags.max_iteration_num): try: for i in range(flags.max_iteration_num): # organize a batch of data for training airway_np = np.zeros([ batch_size_train, block_shape[0], block_shape[1], block_shape[2] ], np.int16) artery_np = np.zeros([ batch_size_train, block_shape[0], block_shape[1], block_shape[2] ], np.int16) # lung_np = np.zeros([batch_size_train,block_shape[0],block_shape[1],block_shape[2]], np.int16) original_np = np.zeros([ batch_size_train, block_shape[0], block_shape[1], block_shape[2] ], np.int16) # store values into data block for m in range(flags.batch_size_train): artery_data, airway_data, original_data = \ sess.run([artery_block, airway_block, original_block]) airway_np[m, :, :, :] += airway_data artery_np[m, :, :, :] += artery_data # lung_np[m, :, :, :] += lung_data original_np[m, :, :, :] += original_data train_ge_, train_dis_, step_num = sess.run( [ge_train_op, dis_train_op, global_step], feed_dict={ X: original_np, airway_lable: artery_np, artery_lable: artery_np, training: True }) if i % 10 == 0: sum_train, accuracy_artery, accuracy_airway, \ artery_l_val, total_l_val,total_l_dis \ = sess.run([merge_summary_op, artery_acc, airway_acc, artery_loss, total_g_loss,gan_d_loss], feed_dict={X: original_np, airway_lable: artery_np, artery_lable: artery_np, training: False}) summary_writer_train.add_summary( sum_train, global_step=int(step_num)) print "train :\nstep %d , artery loss = %f total generator loss = %f total discriminator loss= %f \n\t\t\tairway accuracy = %f , artery accuracy = %f\n =====================" \ % (int(step_num), artery_l_val, total_l_val,total_l_dis , accuracy_airway, accuracy_artery) if i % test_step == 0 and i > 0: # block testing part airway_np_test = np.zeros([ batch_size_train, block_shape[0], block_shape[1], block_shape[2] ], np.int16) artery_np_test = np.zeros([ batch_size_train, block_shape[0], block_shape[1], block_shape[2] ], np.int16) # lung_np_test = np.zeros([batch_size_train, block_shape[0], block_shape[1], block_shape[2]], np.int16) original_np_test = np.zeros([ batch_size_train, block_shape[0], block_shape[1], block_shape[2] ], np.int16) # store values into data block for m in range(flags.batch_size_train): artery_data_test, airway_data_test, original_data_test = \ sess.run([artery_block_test, airway_block_test, original_block_test]) airway_np_test[m, :, :, :] += airway_data_test artery_np_test[m, :, :, :] += artery_data_test # lung_np_test[m, :, :, :] += lung_data_test original_np_test[m, :, :, :] += original_data_test sum_test, accuracy_artery, accuracy_airway, \ artery_l_val, total_l_val, \ artery_np_pred,artery_np_sig\ = sess.run([merge_summary_op, artery_acc, airway_acc, artery_loss, total_g_loss, artery_pred,artery_sig], feed_dict={X: original_np_test, airway_lable: artery_np_test, artery_lable: artery_np_test, training: False}) summary_writer_test.add_summary( sum_test, global_step=int(step_num)) print "\ntest :\nstep %d , artery loss = %f total loss = %f \n\t airway accuracy = %f , artery accuracy = %f\n=====================" \ % (int(step_num), artery_l_val, total_l_val , accuracy_airway, accuracy_artery) # print "airway percentage : ",str(np.float32(np.sum(np.float32(airway_np_test))/(flags.batch_size_train*block_shape[0]*block_shape[1]*block_shape[2]))) print "artery percentage : ", str( np.float32( np.sum(np.float32(artery_np_test)) / (flags.batch_size_train * block_shape[0] * block_shape[1] * block_shape[2]))) # print "prediction of airway : maximum = ",np.max(airway_np_sig)," minimum = ",np.min(airway_np_sig) print "prediction of artery : maximum = ", np.max( artery_np_sig), " minimum = ", np.min( artery_np_sig), '\n' # print 'airway_log_mean = ',airway_log_mean,' airway_mask_mean = ',airway_mask_mean # print 'lung_log_mean = ',lung_log_mean,' lung_mask_mean = ',lung_mask_mean # print 'artery_log_mean = ',artery_log_mean,' artery_mask_mean = ',artery_mask_mean if i % 100 == 0: saver.save(sess, self.train_models_dir + "train_models.ckpt") print "regular model saved! step count : ", step_num except Exception, e: print e # exit(2) coord.request_stop(e) coord.request_stop() coord.join(enqueue_threads) coord.join(enqueue_threads_test)
def batch_inputs(dataset, log_annotated_images, train, num_readers, filter_blacklist, scope_name): with tf.device('/cpu:0'), tf.name_scope(scope_name): data_files = dataset.data_files() filename_queue = tf.train.string_input_producer( data_files, shuffle=train, capacity=INPUT_QUEUE_MEMORY_FACTOR * 2 if train else 1) num_preprocess_threads = PREPROCESS_THREADS examples_per_shard = EXAMPLES_PER_SHARD min_queue_examples = examples_per_shard * INPUT_QUEUE_MEMORY_FACTOR if train: examples_queue = tf.RandomShuffleQueue( capacity=min_queue_examples + 3 * dataset.batch_size, min_after_dequeue=min_queue_examples, dtypes=[tf.string]) else: examples_queue = tf.FIFOQueue(capacity=examples_per_shard + 3 * dataset.batch_size, dtypes=[tf.string]) if num_readers > 1: enqueue_ops = [] for _ in range(num_readers): reader = tf.TFRecordReader() _, value = reader.read(filename_queue) enqueue_ops.append(examples_queue.enqueue([value])) tf.train.queue_runner.add_queue_runner( tf.train.queue_runner.QueueRunner(examples_queue, enqueue_ops)) example_serialized = examples_queue.dequeue() else: reader = tf.TFRecordReader() _, example_serialized = reader.read(filename_queue) images_and_labels = [] for thread_id in range(num_preprocess_threads): image_buffer, label_index, bbox, text, synset, filename =\ parse_example_proto(example_serialized) if not filter_blacklist or \ filename != ["ILSVRC2012_val_"+("00000000"+str(bli))[:8]+".JPG" for bli in dataset.bl_images]: image = image_preprocessing(image_buffer, dataset.image_size, dataset.image_size, bbox, label_index, text, synset, log_annotated_images, train, thread_id) images_and_labels.append([image, label_index, text, synset]) images, labels, texts, synsets = tf.train.batch_join( images_and_labels, batch_size=dataset.batch_size // dataset.num_gpus, capacity=2 * num_preprocess_threads * dataset.batch_size) images = tf.cast(images, tf.float32) images = tf.reshape(images, shape=[ dataset.batch_size // dataset.num_gpus, dataset.image_size, dataset.image_size, 3 ]) labels = tf.reshape(labels, [dataset.batch_size // dataset.num_gpus]) return images, tf.one_hot(labels, dataset.num_classes())
def train(): """The main function that runs training""" ## data image, ih, iw, gt_boxes, gt_masks, num_instances, img_id = \ datasets.get_dataset(FLAGS.dataset_name, FLAGS.dataset_split_name, FLAGS.dataset_dir, FLAGS.im_batch, is_training=True) data_queue = tf.RandomShuffleQueue( capacity=32, min_after_dequeue=16, dtypes=(image.dtype, ih.dtype, iw.dtype, gt_boxes.dtype, gt_masks.dtype, num_instances.dtype, img_id.dtype)) enqueue_op = data_queue.enqueue( (image, ih, iw, gt_boxes, gt_masks, num_instances, img_id)) data_queue_runner = tf.train.QueueRunner(data_queue, [enqueue_op] * 4) tf.add_to_collection(tf.GraphKeys.QUEUE_RUNNERS, data_queue_runner) (image, ih, iw, gt_boxes, gt_masks, num_instances, img_id) = data_queue.dequeue() im_shape = tf.shape(image) image = tf.reshape(image, (im_shape[0], im_shape[1], im_shape[2], 3)) ## network logits, end_points, pyramid_map = network.get_network( FLAGS.network, image, weight_decay=FLAGS.weight_decay) outputs = pyramid_network.build(end_points, ih, iw, pyramid_map, num_classes=81, base_anchors=9, is_training=True, gt_boxes=gt_boxes, gt_masks=gt_masks, loss_weights=[0.2, 0.2, 1.0, 0.2, 1.0]) total_loss = outputs['total_loss'] losses = outputs['losses'] batch_info = outputs['batch_info'] regular_loss = tf.add_n( tf.get_collection(tf.GraphKeys.REGULARIZATION_LOSSES)) ## solvers global_step = slim.create_global_step() update_op = solve(global_step) cropped_rois = tf.get_collection('__CROPPED__')[0] transposed = tf.get_collection('__TRANSPOSED__')[0] gpu_options = tf.GPUOptions(per_process_gpu_memory_fraction=0.8) sess = tf.Session(config=tf.ConfigProto(gpu_options=gpu_options)) init_op = tf.group(tf.global_variables_initializer(), tf.local_variables_initializer()) sess.run(init_op) summary_op = tf.summary.merge_all() logdir = os.path.join(FLAGS.train_dir, strftime('%Y%m%d%H%M%S', gmtime())) if not os.path.exists(logdir): os.makedirs(logdir) summary_writer = tf.summary.FileWriter(logdir, graph=sess.graph) ## restore restore(sess) ## main loop coord = tf.train.Coordinator() threads = [] # print (tf.get_collection(tf.GraphKeys.QUEUE_RUNNERS)) for qr in tf.get_collection(tf.GraphKeys.QUEUE_RUNNERS): threads.extend( qr.create_threads(sess, coord=coord, daemon=True, start=True)) tf.train.start_queue_runners(sess=sess, coord=coord) saver = tf.train.Saver(max_to_keep=20) for step in range(FLAGS.max_iters): start_time = time.time() s_, tot_loss, reg_lossnp, img_id_str, \ rpn_box_loss, rpn_cls_loss, refined_box_loss, refined_cls_loss, mask_loss, \ gt_boxesnp, \ rpn_batch_pos, rpn_batch, refine_batch_pos, refine_batch, mask_batch_pos, mask_batch = \ sess.run([update_op, total_loss, regular_loss, img_id] + losses + [gt_boxes] + batch_info ) duration_time = time.time() - start_time if step % 1 == 0: print( """iter %d: image-id:%07d, time:%.3f(sec), regular_loss: %.6f, """ """total-loss %.4f(%.4f, %.4f, %.6f, %.4f, %.4f), """ """instances: %d, """ """batch:(%d|%d, %d|%d, %d|%d)""" % (step, img_id_str, duration_time, reg_lossnp, tot_loss, rpn_box_loss, rpn_cls_loss, refined_box_loss, refined_cls_loss, mask_loss, gt_boxesnp.shape[0], rpn_batch_pos, rpn_batch, refine_batch_pos, refine_batch, mask_batch_pos, mask_batch)) if np.isnan(tot_loss) or np.isinf(tot_loss): print(gt_boxesnp) raise if step % 100 == 0: summary_str = sess.run(summary_op) summary_writer.add_summary(summary_str, step) if (step % 10000 == 0 or step + 1 == FLAGS.max_iters) and step != 0: checkpoint_path = os.path.join( FLAGS.train_dir, FLAGS.dataset_name + '_' + FLAGS.network + '_model.ckpt') saver.save(sess, checkpoint_path, global_step=step) if coord.should_stop(): coord.request_stop() coord.join(threads)
def cifar10(path=pathcifar, activation="sigmoid", conv_channels=(16, 16, 16), linear_layers=32, batch_size=128, num_threads=4, min_queue_examples=1000, mode="train"): """Cifar10 classification with a convolutional network.""" # Data. _open_cifar10(path) if activation == "sigmoid": activation_op = tf.sigmoid elif activation == "relu": activation_op = tf.nn.relu else: raise ValueError("{} activation not supported".format(activation)) # Read images and labels from disk. if mode == "train": filenames = [ os.path.join(path, CIFAR10_FOLDER, "data_batch_{}.bin".format(i)) for i in range(1, 6) ] elif mode == "test": filenames = [os.path.join(path, "test_batch.bin")] else: raise ValueError("Mode {} not recognised".format(mode)) depth = 3 height = 32 width = 32 label_bytes = 1 image_bytes = depth * height * width record_bytes = label_bytes + image_bytes reader = tf.FixedLengthRecordReader(record_bytes=record_bytes) _, record = reader.read(tf.train.string_input_producer(filenames)) record_bytes = tf.decode_raw(record, tf.uint8) label = tf.cast(tf.slice(record_bytes, [0], [label_bytes]), tf.int32) raw_image = tf.slice(record_bytes, [label_bytes], [image_bytes]) image = tf.cast(tf.reshape(raw_image, [depth, height, width]), tf.float32) # height x width x depth. image = tf.transpose(image, [1, 2, 0]) image = tf.div(image, 255) queue = tf.RandomShuffleQueue( capacity=min_queue_examples + 3 * batch_size, min_after_dequeue=min_queue_examples, dtypes=[tf.float32, tf.int32], shapes=[image.get_shape(), label.get_shape()]) enqueue_ops = [queue.enqueue([image, label]) for _ in range(num_threads)] tf.train.add_queue_runner(tf.train.QueueRunner(queue, enqueue_ops)) with tf.name_scope('Optimizee_loss'): def compute_loss(): image_batch, label_batch = queue.dequeue_many(batch_size) label_batch = tf.reshape(label_batch, [batch_size]) output = image_batch with tf.variable_scope('ConvMLP', reuse=tf.AUTO_REUSE): conv1_w = tf.get_variable( "conv1_w", shape=[5, 5, depth, conv_channels[0]], dtype=tf.float32, initializer=tf.random_normal_initializer(stddev=0.01)) conv1_b = tf.get_variable( "conv1_b", shape=[ conv_channels[0], ], dtype=tf.float32, initializer=tf.random_normal_initializer(stddev=0.01)) conv1_beta = tf.get_variable( "conv1_beta", shape=[1, 1, 1, conv_channels[0]], dtype=tf.float32, initializer=tf.random_normal_initializer(stddev=0.01)) conv2_w = tf.get_variable( "conv2_w", shape=[5, 5, conv_channels[0], conv_channels[1]], dtype=tf.float32, initializer=tf.random_normal_initializer(stddev=0.01)) conv2_b = tf.get_variable( "conv2_b", shape=[ conv_channels[1], ], dtype=tf.float32, initializer=tf.random_normal_initializer(stddev=0.01)) conv2_beta = tf.get_variable( "conv2_beta", shape=[1, 1, 1, conv_channels[1]], dtype=tf.float32, initializer=tf.random_normal_initializer(stddev=0.01)) conv3_w = tf.get_variable( "conv3_w", shape=[5, 5, conv_channels[1], conv_channels[2]], dtype=tf.float32, initializer=tf.random_normal_initializer(stddev=0.01)) conv3_b = tf.get_variable( "conv3_b", shape=[ conv_channels[2], ], dtype=tf.float32, initializer=tf.random_normal_initializer(stddev=0.01)) conv3_beta = tf.get_variable( "conv3_beta", shape=[1, 1, 1, conv_channels[2]], dtype=tf.float32, initializer=tf.random_normal_initializer(stddev=0.01)) output = tf.nn.convolution(output, conv1_w, padding='SAME', strides=[1, 1]) output = tf.nn.relu(tf.nn.bias_add(output, conv1_b)) output = tf.nn.max_pool(output, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding='SAME') b_m_1, b_v_1 = tf.nn.moments(output, axes=[0, 1, 2]) output = tf.nn.batch_normalization(output, b_m_1, b_v_1, conv1_beta, scale=None, variance_epsilon=1e-8) output = tf.nn.convolution(output, conv2_w, padding='SAME', strides=[1, 1]) output = tf.nn.relu(tf.nn.bias_add(output, conv2_b)) output = tf.nn.max_pool(output, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding='SAME') b_m_2, b_v_2 = tf.nn.moments(output, [0, 1, 2]) output = tf.nn.batch_normalization(output, b_m_2, b_v_2, conv2_beta, scale=None, variance_epsilon=1e-8) output = tf.nn.convolution(output, conv3_w, padding='SAME', strides=[1, 1]) output = tf.nn.relu(tf.nn.bias_add(output, conv3_b)) output = tf.nn.max_pool(output, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding='SAME') b_m_3, b_v_3 = tf.nn.moments(output, [0, 1, 2]) output = tf.nn.batch_normalization(output, b_m_3, b_v_3, conv3_beta, scale=None, variance_epsilon=1e-8) output = tf.layers.flatten(output) W_in = tf.get_variable( "W_in", shape=[output.shape[1], linear_layers], dtype=tf.float32, initializer=tf.random_normal_initializer(stddev=0.01)) b_in = tf.get_variable( "b_in", shape=[ linear_layers, ], dtype=tf.float32, initializer=tf.random_normal_initializer(stddev=0.01)) W_out = tf.get_variable( "W_out", shape=[linear_layers, 10], dtype=tf.float32, initializer=tf.random_normal_initializer(stddev=0.01)) b_out = tf.get_variable( "b_out", shape=[ 10, ], dtype=tf.float32, initializer=tf.random_normal_initializer(stddev=0.01)) layer_out = activation_op(tf.add(tf.matmul(output, W_in), b_in)) output = tf.add(tf.matmul(layer_out, W_out), b_out) loss = tf.nn.sparse_softmax_cross_entropy_with_logits( logits=output, labels=label_batch) return tf.reduce_mean(loss) with tf.name_scope('Convex_loss'): def convex_loss(): with tf.variable_scope('conv_var', reuse=tf.AUTO_REUSE): v = tf.get_variable( "v", shape=[1, 10], dtype=tf.float32, initializer=tf.random_normal_initializer(stddev=0.01)) # Non-trainable variables. target = tf.get_variable( "target", shape=[1, 10], dtype=tf.float32, initializer=tf.random_uniform_initializer(), trainable=False) return tf.reduce_mean( tf.clip_by_value(tf.square(v - target), 0, 10)) return collections.OrderedDict([('Opt_loss', compute_loss), ('Aux_loss', convex_loss)])
def _create_queue_and_ops(self, window, enqueue_size=1, dequeue_size=1): """ Create a shuffled queue or FIFO queue, and create queue operations. This should be called before ``tf.Graph.finalize``. """ self._window = window try: is_dynamic_window = window.has_dynamic_shapes except AttributeError: tf.logging.fatal( "unrecognised window format, expecting a" "niftynet.engine.image_window.ImageWindow instance") raise if is_dynamic_window and enqueue_size > 1: tf.logging.warning( "using dynamic window size, buffer input size is set to 1") if is_dynamic_window and dequeue_size > 1: tf.logging.warning( "using dynamic window size, network batch size is set to 1") _enqueue_size = 1 if is_dynamic_window else enqueue_size # batch_size is 1 if is_dynamic_window because # RandomShuffleQueue's DequeueMany and DequeueUpTo require # the components to have specified shapes self._batch_size = 1 if is_dynamic_window else dequeue_size self.capacity = int(max(self.capacity, round(self._batch_size * 2.5))) assert self._batch_size <= self.capacity, \ "batch size {} is larger than the buffer size {}, " \ "please increase the queue capacity " \ "or decrease the batch size".format( self._batch_size, self.capacity) tf.logging.info('buffering with %s windows', self.capacity) try: self.placeholders_dict = window.placeholders_dict(_enqueue_size) except AttributeError: tf.logging.fatal( "unrecognised window format, expecting a" "niftynet.engine.image_window.ImageWindow instance") raise names = list(self.placeholders_dict) placeholders = list(self.placeholders_dict.values()) input_dtypes = [holder.dtype for holder in placeholders] input_shapes = [holder.shape[1:] for holder in placeholders] \ if not is_dynamic_window else None # create a queue # pylint: disable=redefined-variable-type if self.shuffle: self._queue = tf.RandomShuffleQueue( capacity=self.capacity, min_after_dequeue=self.capacity // 2, dtypes=input_dtypes, shapes=input_shapes, names=names, name="shuffled_queue") assert (self.capacity - self.capacity // 2) >= self._batch_size, \ "batch size larger than the largest possible dequeue size" \ "of the current queue capacity" else: self._queue = tf.FIFOQueue(capacity=self.capacity, dtypes=input_dtypes, shapes=input_shapes, names=names, name="FIFO_queue") # create queue operations if is_dynamic_window: self._enqueue_op = self._queue.enqueue(self.placeholders_dict) self._dequeue_func = self._queue.dequeue else: self._enqueue_op = self._queue.enqueue_many(self.placeholders_dict) self._dequeue_func = self._queue.dequeue_many self._query_queue_size_op = self._queue.size() self._close_queue_op = self._queue.close(cancel_pending_enqueues=True)
#生成三个样本文件,每个文件包含5列,假设前4列为特征,最后1列为标签 data = np.zeros([20, 5]) np.savetxt('./file0.csv', data, fmt='%d', delimiter=',') data += 1 np.savetxt('./file1.csv', data, fmt='%d', delimiter=',') data += 1 np.savetxt('./file2.csv', data, fmt='%d', delimiter=',') # 创建pipeline数据流。 #定义FilenameQueue filename_queue = tf.train.string_input_producer( ["file%d.csv" % i for i in range(3)]) #定义ExampleQueue example_queue = tf.RandomShuffleQueue(capacity=1000, min_after_dequeue=0, dtypes=[tf.int32, tf.int32], shapes=[[4], [1]]) #读取CSV文件,每次读一行 reader = tf.TextLineReader() key, value = reader.read(filename_queue) #对一行数据进行解码 record_defaults = [[1], [1], [1], [1], [1]] col1, col2, col3, col4, col5 = tf.decode_csv(value, record_defaults=record_defaults) features = tf.stack([col1, col2, col3, col4]) #将特征和标签push进ExampleQueue enq_op = example_queue.enqueue([features, [col5]]) #使用QueueRunner创建两个进程加载数据到ExampleQueue qr = tf.train.QueueRunner(example_queue, [enq_op] * 2) #使用此方法方便后面tf.train.start_queue_runner统一开始进程 tf.train.add_queue_runner(qr)
def prefetch_input_data(reader, file_pattern, shuffle, capacity, dataset, num_reader_threads=1): """Prefetches string values from disk into an input queue. Args: reader: Instance of tf.ReaderBase. file_pattern: Comma-separated list of file patterns (e.g. "/tmp/train_data-?????-of-00100", where '?' acts as a wildcard that matches any character). shuffle: Boolean; whether to randomly shuffle the input data. capacity: Queue capacity (number of records). num_reader_threads: Number of reader threads feeding into the queue. Returns: A Queue containing prefetched string values. """ data_files = [] print("file_pattern is ", file_pattern) for pattern in file_pattern.split(","): data_files.extend(tf.gfile.Glob(pattern)) if not data_files: tf.logging.fatal("Found no input files matching %s", file_pattern) else: tf.logging.info("Prefetching values from %d files matching %s", len(data_files), file_pattern) filename_queue = tf.train.string_input_producer(data_files, shuffle=shuffle, capacity=16, name="filename_queue" + dataset) if shuffle: min_after_dequeue = int(0.6 * capacity) values_queue = tf.RandomShuffleQueue( capacity=capacity, min_after_dequeue=min_after_dequeue, dtypes=[tf.string], shapes=[[]], name="random_input_queue" + dataset) else: values_queue = tf.FIFOQueue(capacity=capacity, dtypes=[tf.string], shapes=[[]], name="fifo_input_queue" + dataset) enqueue_ops = [] for _ in range(num_reader_threads): key, value = reader.read(filename_queue) enqueue_ops.append(values_queue.enqueue([value])) tf.train.queue_runner.add_queue_runner( tf.train.queue_runner.QueueRunner(values_queue, enqueue_ops)) #tf.train.queue_runner.add_queue_runner(video_queue) ### MAYBE IMPORTANT #tf.summary.scalar("queue/%s/fraction_of_%d_full" % (values_queue.name,capacity),tf.cast(values_queue.size(), tf.float32) * (1.0 / capacity)) return values_queue
def batch_inputs(data_dir, batch_size, image_size, train, preprocess_operation, num_preprocess_threads=None, num_readers=1, examples_per_shard=1024, input_queue_memory_factor=16): """Contruct batches of training or evaluation examples from the image dataset. Args: dataset: instance of Dataset class specifying the dataset. See dataset.py for details. batch_size: integer train: boolean num_preprocess_threads: integer, total number of preprocessing threads num_readers: integer, number of parallel readers Returns: images: 4-D float Tensor of a batch of images labels: 1-D integer Tensor of [batch_size]. Raises: ValueError: if data is not found """ with tf.name_scope('batch_processing'): if train == True: subset = 'train' else: subset = 'validation' # Reshape images into these desired dimensions. if len(image_size) == 1: if isinstance(image_size, list) or isinstance(image_size, tuple): image_size = image_size[0] height = image_size width = image_size depth = 3 elif len(image_size) == 2: height = image_size[0] width = image_size[1] depth = 3 elif len(image_size) == 3: height = image_size[0] width = image_size[1] depth = image_size[2] else: print('Wrong image_size dimension %d' % len(image_size)) exit(-1) tf_record_pattern = os.path.join(data_dir, '%s-*' % subset) data_files = tf.gfile.Glob(tf_record_pattern) if not data_files: print('No files found for dataset %s at %s' % (subset, data_dir)) exit(-1) if data_files is None: raise ValueError('No data files found for this dataset') # Create filename_queue if train: filename_queue = tf.train.string_input_producer(data_files, shuffle=True, capacity=16) else: filename_queue = tf.train.string_input_producer(data_files, shuffle=False, capacity=1) if num_preprocess_threads is None: num_preprocess_threads = 4 if num_readers is None: num_readers = 1 # Approximate number of examples per shard. if examples_per_shard is None: examples_per_shard = 1024 if input_queue_memory_factor is None: input_queue_memory_factor = 16 # Size the random shuffle queue to balance between good global # mixing (more examples) and memory use (fewer examples). # 1 image uses 299*299*3*4 bytes = 1MB # The default input_queue_memory_factor is 16 implying a shuffling queue # size: examples_per_shard * 16 * 1MB = 17.6GB min_queue_examples = examples_per_shard * input_queue_memory_factor if train: examples_queue = tf.RandomShuffleQueue( capacity=min_queue_examples + 3 * batch_size, min_after_dequeue=min_queue_examples, dtypes=[tf.string]) else: examples_queue = tf.FIFOQueue(capacity=examples_per_shard + 3 * batch_size, dtypes=[tf.string]) # Create multiple readers to populate the queue of examples. if num_readers > 1: enqueue_ops = [] for _ in range(num_readers): reader = tf.TFRecordReader() _, value = reader.read(filename_queue) enqueue_ops.append(examples_queue.enqueue([value])) tf.train.queue_runner.add_queue_runner( tf.train.queue_runner.QueueRunner(examples_queue, enqueue_ops)) example_serialized = examples_queue.dequeue() else: reader = tf.TFRecordReader() _, example_serialized = reader.read(filename_queue) images_and_labels = [] for thread_id in range(num_preprocess_threads): # Parse a serialized Example proto to extract the image and metadata. image_buffer, label_index, _ = parse_example_proto( example_serialized) '''image_preprocessing''' image = image_preprocessing(image_buffer, preprocess_operation, train, height, width, depth, thread_id) images_and_labels.append([image, label_index, _]) images, label_index_batch, label_text = tf.train.batch_join( images_and_labels, batch_size=batch_size, capacity=2 * num_preprocess_threads * batch_size) images = tf.cast(images, tf.float32) images = tf.reshape(images, shape=[batch_size, height, width, depth]) # Display the training images in the visualizer. tf.image_summary('images', images) return images, tf.reshape(label_index_batch, [batch_size]), tf.reshape( label_text, [batch_size])
def _build(self): """Returns a tuple containing image, image metadata and label. Does not receive any input since it doesn't depend on anything inside the graph and it's the starting point of it. Returns: dequeue_dict ({}): Dequeued dict returning and image, bounding boxes, filename and the scaling factor used. TODO: Join filename, scaling_factor (and possible other fields) into a metadata. """ # Find split file from which we are going to read. split_path = os.path.join( self._dataset_dir, '{}.tfrecords'.format(self._split) ) if not tf.gfile.Exists(split_path): raise InvalidDataDirectory( '"{}" does not exist.'.format(split_path) ) # String input producer allows for a variable number of files to read # from. We just know we have a single file. filename_queue = tf.train.string_input_producer( [split_path], num_epochs=self._num_epochs, seed=self._seed ) # Define reader to parse records. reader = tf.TFRecordReader() _, raw_record = reader.read(filename_queue) # We parse variable length features (bboxes in a image) as sequence # features context_example, sequence_example = tf.parse_single_sequence_example( raw_record, context_features=self._context_features, sequence_features=self._sequence_features ) # Decode and preprocess the example (crop, adjust mean and variance). # image_jpeg = tf.decode_raw(example['image_raw'], tf.string) image_raw = tf.image.decode_jpeg( context_example['image_raw'], channels=3 ) # tf.summary.image('image_raw', image_raw, max_outputs=20) # Do we need per_image_standardization? Do it depend on pretrained? image = tf.cast(image_raw, tf.float32) height = tf.cast(context_example['height'], tf.int32) width = tf.cast(context_example['width'], tf.int32) image_shape = tf.stack([height, width, 3]) image = tf.reshape(image, image_shape) label = self.sparse_to_tensor(sequence_example['label']) xmin = self.sparse_to_tensor(sequence_example['xmin']) xmax = self.sparse_to_tensor(sequence_example['xmax']) ymin = self.sparse_to_tensor(sequence_example['ymin']) ymax = self.sparse_to_tensor(sequence_example['ymax']) # Stack parsed tensors to define bounding boxes of shape (num_boxes, 5) bboxes = tf.stack([xmin, ymin, xmax, ymax, label], axis=1) # Resize images (if needed) image, bboxes, scale_factor = self._resize_image(image, bboxes) image, bboxes, applied_augmentations = self._augment(image, bboxes) filename = tf.cast(context_example['filename'], tf.string) # TODO: Send additional metadata through the queue (scale_factor, # applied_augmentations) queue_dtypes = [tf.float32, tf.int32, tf.string] queue_names = ['image', 'bboxes', 'filename'] if self._random_shuffle: queue = tf.RandomShuffleQueue( capacity=100, min_after_dequeue=0, dtypes=queue_dtypes, names=queue_names, name='tfrecord_random_queue', seed=self._seed ) else: queue = tf.FIFOQueue( capacity=100, dtypes=queue_dtypes, names=queue_names, name='tfrecord_fifo_queue' ) # Generate queueing ops for QueueRunner. enqueue_ops = [queue.enqueue({ 'image': image, 'bboxes': bboxes, 'filename': filename, })] * 20 tf.train.add_queue_runner(tf.train.QueueRunner(queue, enqueue_ops)) return queue.dequeue()
def __init__(self, num_actions, observation_size): self.num_actions = num_actions self.observation_size = observation_size config = tf.ConfigProto() config.gpu_options.allow_growth = True self.graph = tf.get_default_graph() self.sess = tf.Session(config=config) self.logger = tf.summary.FileWriter("logs") self.batch_size = 64 self.max_experience_size = 1000000 self.start_learning_after = 5000 self.store_every_nth = 5 self.inp_rewards = tf.placeholder(tf.float32, (None, )) self.inp_actions = tf.placeholder(tf.float32, (None, num_actions)) self.inp_prev_states = tf.placeholder(tf.float32, (None, observation_size)) self.inp_next_states = tf.placeholder(tf.float32, (None, observation_size)) all_experience = tf.RandomShuffleQueue( capacity=self.max_experience_size, min_after_dequeue=self.start_learning_after, dtypes=[tf.float32, tf.float32, tf.float32, tf.float32], shapes=[(), (num_actions, ), (observation_size, ), (observation_size, )]) exp_fifo_queue = tf.FIFOQueue( capacity=self.max_experience_size, dtypes=[tf.float32, tf.float32, tf.float32, tf.float32], shapes=[(), (num_actions, ), (observation_size, ), (observation_size, )]) self.exp_enqueue_op = all_experience.enqueue_many([ self.inp_rewards, self.inp_actions, self.inp_prev_states, self.inp_next_states ]) self.exp_fifo_enqueue_op = exp_fifo_queue.enqueue_many([ self.inp_rewards, self.inp_actions, self.inp_prev_states, self.inp_next_states ]) self.exp_size_op = all_experience.size() [rewards, actions, prev_states, next_states] = all_experience.dequeue_many(self.batch_size) self.dequeued_rewards = rewards self.dequeued_actions = actions self.dequeued_prev_states = prev_states self.dequeued_next_states = next_states [fifo_rewards, fifo_actions, fifo_prev_states, fifo_next_states] = exp_fifo_queue.dequeue_many(self.batch_size) self.dequeued_fifo_rewards = fifo_rewards self.dequeued_fifo_actions = fifo_actions self.dequeued_fifo_prev_states = fifo_prev_states self.dequeued_fifo_next_states = fifo_next_states self.exp_fifo_size_op = exp_fifo_queue.size() self.sum_rewards = 0 self.store_index = 0 self.stored_count = 0 self.train_ops = [] self.store_ops = [] self.train_listener = None self.store_listener = None
def batch_inputs(dataset, batch_size, train, num_preprocess_threads=None, num_readers=1, regular=True): """Contruct batches of training or evaluation examples from the image dataset. Args: dataset: instance of Dataset class specifying the dataset. See dataset.py for details. batch_size: integer train: boolean num_preprocess_threads: integer, total number of preprocessing threads num_readers: integer, number of parallel readers Returns: images: 4-D float Tensor of a batch of images labels: 1-D integer Tensor of [batch_size]. Raises: ValueError: if data is not found """ with tf.name_scope('batch_processing'): data_files = dataset.data_files() if data_files is None: raise ValueError('No data files found for this dataset') # Create filename_queue if train: filename_queue = tf.train.string_input_producer(data_files, shuffle=True, capacity=16) else: filename_queue = tf.train.string_input_producer(data_files, shuffle=False, capacity=1) if num_preprocess_threads is None: num_preprocess_threads = FLAGS.num_preprocess_threads if num_preprocess_threads % 4: raise ValueError('Please make num_preprocess_threads a multiple ' 'of 4 (%d % 4 != 0).', num_preprocess_threads) if num_readers is None: num_readers = FLAGS.num_readers if num_readers < 1: raise ValueError('Please make num_readers at least 1') # Approximate number of examples per shard. examples_per_shard = 1024 # Size the random shuffle queue to balance between good global # mixing (more examples) and memory use (fewer examples). # 1 image uses 299*299*3*4 bytes = 1MB # The default input_queue_memory_factor is 16 implying a shuffling queue # size: examples_per_shard * 16 * 1MB = 17.6GB min_queue_examples = examples_per_shard * FLAGS.input_queue_memory_factor if train: examples_queue = tf.RandomShuffleQueue( capacity=min_queue_examples + 3 * batch_size, min_after_dequeue=min_queue_examples, dtypes=[tf.string]) else: examples_queue = tf.FIFOQueue( capacity=examples_per_shard + 3 * batch_size, dtypes=[tf.string]) # Create multiple readers to populate the queue of examples. if num_readers > 1: enqueue_ops = [] for _ in range(num_readers): reader = dataset.reader() _, value = reader.read(filename_queue) enqueue_ops.append(examples_queue.enqueue([value])) tf.train.queue_runner.add_queue_runner( tf.train.queue_runner.QueueRunner(examples_queue, enqueue_ops)) example_serialized = examples_queue.dequeue() else: reader = dataset.reader() _, example_serialized = reader.read(filename_queue) images_and_labels = [] for thread_id in range(num_preprocess_threads): # Parse a serialized Example proto to extract the image and metadata. image_buffer, label_index, bbox, _ = parse_example_proto( example_serialized) image = image_preprocessing(image_buffer, bbox, train, thread_id, regular=regular) images_and_labels.append([image, label_index]) images, label_index_batch = tf.train.batch_join( images_and_labels, batch_size=batch_size, capacity=2 * num_preprocess_threads * batch_size) # Reshape images into these desired dimensions. height = FLAGS.image_size width = FLAGS.image_size depth = 3 images = tf.cast(images, tf.float32) images = tf.reshape(images, shape=[batch_size, height, width, depth]) # Display the traioring images in the visualizer. tf.summary.image('images', images) return images, tf.reshape(label_index_batch, [batch_size])
def prefetch_input_data(reader, file_pattern, is_training, batch_size, values_per_shard, input_queue_capacity_factor=16, num_reader_threads=1, shard_queue_name="filename_queue", value_queue_name="input_queue"): """Prefetches string values from disk into an input queue. In training the capacity of the queue is important because a larger queue means better mixing of training examples between shards. The minimum number of values kept in the queue is values_per_shard * input_queue_capacity_factor, where input_queue_memory factor should be chosen to trade-off better mixing with memory usage. Args: reader: Instance of tf.ReaderBase. file_pattern: Comma-separated list of file patterns (e.g. /tmp/train_data-?????-of-00100). is_training: Boolean; whether prefetching for training or eval. batch_size: Model batch size used to determine queue capacity. values_per_shard: Approximate number of values per shard. input_queue_capacity_factor: Minimum number of values to keep in the queue in multiples of values_per_shard. See comments above. num_reader_threads: Number of reader threads to fill the queue. shard_queue_name: Name for the shards filename queue. value_queue_name: Name for the values input queue. Returns: A Queue containing prefetched string values. """ # check if dataset file exist data_files = [] for pattern in file_pattern.split(","): data_files.extend(tf.gfile.Glob(pattern)) if not data_files: tf.logging.fatal("Found no input files matching %s", file_pattern) else: tf.logging.info("Prefetching values from %d files matching %s", len(data_files), file_pattern) """ Queues are a convenient TensorFlow mechanism to compute tensors asynchronously using multiple threads. For example in the canonical 'Input Reader' setup one set of threads generates filenames in a queue; a second set of threads read records from the files, processes them, and enqueues tensors on a second queue; a third set of threads dequeues these input records to construct batches and runs them through training operations. """ if is_training: # create a queue to store filenames (string) filename_queue = tf.train.string_input_producer( data_files, shuffle=True, capacity=16, name=shard_queue_name) # calculate min capacity and capacity min_queue_examples = values_per_shard * input_queue_capacity_factor capacity = min_queue_examples + 100 * batch_size # create a queue to store raw data values_queue = tf.RandomShuffleQueue( capacity=capacity, min_after_dequeue=min_queue_examples, dtypes=[tf.string], name="random_" + value_queue_name) else: filename_queue = tf.train.string_input_producer( data_files, shuffle=False, capacity=1, name=shard_queue_name) capacity = values_per_shard + 3 * batch_size values_queue = tf.FIFOQueue( capacity=capacity, dtypes=[tf.string], name="fifo_" + value_queue_name) enqueue_ops = [] for _ in range(num_reader_threads): # read file (value) from filename queue # ps: tf reader is also tf graph operation _, value = reader.read(filename_queue) # values_queue.enqueue is a enqueue operation put value into values_queue enqueue_ops.append(values_queue.enqueue([value])) # values_queue: a queue, enqueue_ops: is a operation on values_queue tf.train.queue_runner.add_queue_runner(tf.train.queue_runner.QueueRunner( values_queue, enqueue_ops)) tf.summary.scalar( "queue/%s/fraction_of_%d_full" % (values_queue.name, capacity), tf.cast(values_queue.size(), tf.float32) * (1. / capacity)) return values_queue
records = get_records(FLAGS.dataset_name, FLAGS.dataset_split_name, FLAGS.dataset_dir, FLAGS.im_batch, is_training=False) image, ih, iw, gt_boxes, gt_masks, num_instances, img_id = \ coco.read(records) image, gt_boxes, gt_masks = \ preprocess_coco.preprocess_image(image, gt_boxes, gt_masks) # using queue to input queue = tf.RandomShuffleQueue(capacity=12, min_after_dequeue=6, dtypes=(image.dtype, ih.dtype, iw.dtype, gt_boxes.dtype, gt_masks.dtype, num_instances.dtype, img_id.dtype)) enqueue_op = queue.enqueue( (image, ih, iw, gt_boxes, gt_masks, num_instances, img_id)) (image_, ih_, iw_, gt_boxes_, gt_masks_, num_instances_, img_id_) = queue.dequeue() qr = tf.train.QueueRunner(queue, [enqueue_op] * 4) sess = tf.Session() init_op = tf.group(tf.global_variables_initializer(), tf.local_variables_initializer()) # init_op = tf.initialize_all_variables() coord = tf.train.Coordinator() enqueue_threads = qr.create_threads(sess, coord=coord, start=True)
#!/usr/bin/python3 # -*- coding: utf-8 -*- # @Time : 2019/12/18 17:19 # @Author : Leslee import tensorflow as tf q = tf.RandomShuffleQueue(capacity=10,min_after_dequeue=2,dtypes="float") sess = tf.Session() for i in range(0,10): sess.run(q.enqueue(i)) # for i in range(0,8): # print(sess.run(q.dequeue())) run_options = tf.RunOptions(timeout_in_ms = 10000) try: print(sess.run(q.dequeue(),options=run_options)) except tf.errors.DeadlineExceededError: print('out of range')
def image_processing_module(dataset, train): """Contruct batches of training or evaluation examples from the image dataset. """ batch_size = FLAGS.batch_size num_readers = FLAGS.num_readers num_preprocess_threads = FLAGS.num_preprocess_threads with tf.device('/cpu:0'): with tf.name_scope('batch_processing'): if train: filename_queue = tf.train.string_input_producer(dataset, shuffle=True, capacity=2) else: filename_queue = tf.train.string_input_producer(dataset, shuffle=False, capacity=1) examples_per_shard = 128 # Shuffling queue size min_queue_examples = examples_per_shard * FLAGS.input_queue_memory_factor if train: examples_queue = tf.RandomShuffleQueue( capacity=min_queue_examples + 3 * batch_size, min_after_dequeue=min_queue_examples, dtypes=[tf.string]) else: examples_queue = tf.FIFOQueue(capacity=examples_per_shard + 3 * batch_size, dtypes=[tf.string]) # Create multiple readers to populate the queue of examples. if num_readers > 1: enqueue_ops = [] for _ in range(num_readers): reader = tf.TFRecordReader() _, value = reader.read(filename_queue) enqueue_ops.append(examples_queue.enqueue([value])) tf.train.queue_runner.add_queue_runner( tf.train.queue_runner.QueueRunner(examples_queue, enqueue_ops)) example_serialized = examples_queue.dequeue() else: reader = tf.TFRecordReader() _, example_serialized = reader.read(filename_queue) images_and_labels = [] for thread_id in range(num_preprocess_threads): # Parse a serialized Examle proto to extract the image and metadata. image_buffer, labels = parse_example_proto(example_serialized) image = image_transform(image_buffer, train, thread_id) if image is not None: images_and_labels.append([image, labels]) images, label_index_batch = tf.train.batch_join( images_and_labels, batch_size=batch_size, capacity=2 * num_preprocess_threads * batch_size) #Reshape images into desired dimentions height = FLAGS.image_size width = FLAGS.image_size depth = 3 images = tf.cast(images, tf.float32) images = tf.reshape(images, shape=[batch_size, height, width, depth]) return images, tf.reshape(label_index_batch, [batch_size])
def cifar10(path, # pylint: disable=invalid-name conv_channels=None, linear_layers=None, batch_norm=True, batch_size=128, num_threads=4, min_queue_examples=1000, mode="train"): """Cifar10 classification with a convolutional network.""" # Data. _maybe_download_cifar10(path) # Read images and labels from disk. if mode == "train": filenames = [os.path.join(path, CIFAR10_FOLDER, "data_batch_{}.bin".format(i)) for i in xrange(1, 6)] elif mode == "test": filenames = [os.path.join(path, "test_batch.bin")] else: raise ValueError("Mode {} not recognised".format(mode)) depth = 3 height = 32 width = 32 label_bytes = 1 image_bytes = depth * height * width record_bytes = label_bytes + image_bytes reader = tf.FixedLengthRecordReader(record_bytes=record_bytes) _, record = reader.read(tf.train.string_input_producer(filenames)) record_bytes = tf.decode_raw(record, tf.uint8) label = tf.cast(tf.slice(record_bytes, [0], [label_bytes]), tf.int32) raw_image = tf.slice(record_bytes, [label_bytes], [image_bytes]) image = tf.cast(tf.reshape(raw_image, [depth, height, width]), tf.float32) # height x width x depth. image = tf.transpose(image, [1, 2, 0]) image = tf.div(image, 255) queue = tf.RandomShuffleQueue(capacity=min_queue_examples + 3 * batch_size, min_after_dequeue=min_queue_examples, dtypes=[tf.float32, tf.int32], shapes=[image.get_shape(), label.get_shape()]) enqueue_ops = [queue.enqueue([image, label]) for _ in xrange(num_threads)] tf.train.add_queue_runner(tf.train.QueueRunner(queue, enqueue_ops)) # Network. def _conv_activation(x): # pylint: disable=invalid-name return tf.nn.max_pool(tf.nn.relu(x), ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding="SAME") conv = nn.ConvNet2D(output_channels=conv_channels, kernel_shapes=[5], strides=[1], paddings=[nn.SAME], activation=_conv_activation, activate_final=True, initializers=_nn_initializers, use_batch_norm=batch_norm) if batch_norm: linear_activation = lambda x: tf.nn.relu(nn.BatchNorm()(x)) else: linear_activation = tf.nn.relu mlp = nn.MLP(list(linear_layers) + [10], activation=linear_activation, initializers=_nn_initializers) network = nn.Sequential([conv, nn.BatchFlatten(), mlp]) def build(): image_batch, label_batch = queue.dequeue_many(batch_size) label_batch = tf.reshape(label_batch, [batch_size]) output = network(image_batch) return _xent_loss(output, label_batch) return build
def enqueue_data(data, capacity, shuffle=False, min_after_dequeue=None, seed=None): """Creates a queue filled from a numpy array or pandas `DataFrame`. Returns a queue filled with the rows of the given array or `DataFrame`. In the case of a pandas `DataFrame`, the first enqueued `Tensor` corresponds to the index of the `DataFrame`. For numpy arrays, the first enqueued `Tensor` contains the row number. Args: data: a numpy `ndarray or` pandas `DataFrame` that will be read into the queue. capacity: the capacity of the queue. shuffle: whether or not to shuffle the rows of the array. min_after_dequeue: minimum number of elements that can remain in the queue after a dequeue operation. Only used when `shuffle` is true. If not set, defaults to `capacity` / 4. seed: used to seed RandomShuffleQueue. Only used when `shuffle` is True. Returns: A queue filled with the rows of the given array or `DataFrame`. Raises: TypeError: `data` is not a Pandas `DataFrame` or a numpy `ndarray`. """ # TODO(jamieas): create multithreaded version of enqueue_data. if isinstance(data, np.ndarray): dtypes = [tf.int64, tf.as_dtype(data.dtype)] shapes = [(), data.shape[1:]] get_feed_fn = _ArrayFeedFn elif HAS_PANDAS and isinstance(data, pd.DataFrame): dtypes = [tf.as_dtype(dt) for dt in [data.index.dtype] + list(data.dtypes)] shapes = [() for _ in dtypes] get_feed_fn = _PandasFeedFn else: raise TypeError( "data must be either a numpy array or pandas DataFrame if pandas is " "installed; got {}".format( type(data).__name__)) placeholders = [tf.placeholder(*type_and_shape) for type_and_shape in zip(dtypes, shapes)] if shuffle: min_after_dequeue = (capacity / 4 if min_after_dequeue is None else min_after_dequeue) queue = tf.RandomShuffleQueue(capacity, min_after_dequeue, dtypes=dtypes, shapes=shapes, seed=seed) else: queue = tf.FIFOQueue(capacity, dtypes=dtypes, shapes=shapes) enqueue_op = queue.enqueue(placeholders) feed_fn = get_feed_fn(placeholders, data) queue_runner = fqr.FeedingQueueRunner(queue=queue, enqueue_ops=[enqueue_op], feed_fn=feed_fn) tf.train.add_queue_runner(queue_runner) return queue
def train(): """The main function that runs training""" ## data image, ih, iw, gt_boxes, gt_masks, num_instances, img_id = \ datasets.get_dataset(FLAGS.dataset_name, FLAGS.dataset_split_name, FLAGS.dataset_dir, FLAGS.im_batch, is_training=True) data_queue = tf.RandomShuffleQueue( capacity=32, min_after_dequeue=16, dtypes=(image.dtype, ih.dtype, iw.dtype, gt_boxes.dtype, gt_masks.dtype, num_instances.dtype, img_id.dtype)) enqueue_op = data_queue.enqueue( (image, ih, iw, gt_boxes, gt_masks, num_instances, img_id)) data_queue_runner = tf.train.QueueRunner(data_queue, [enqueue_op] * 4) tf.add_to_collection(tf.GraphKeys.QUEUE_RUNNERS, data_queue_runner) (image, ih, iw, gt_boxes, gt_masks, num_instances, img_id) = data_queue.dequeue() im_shape = tf.shape(image) image = tf.reshape(image, (im_shape[0], im_shape[1], im_shape[2], 3)) ## network logits, end_points, pyramid_map = network.get_network( FLAGS.network, image, weight_decay=FLAGS.weight_decay, is_training=True) outputs = pyramid_network.build(end_points, im_shape[1], im_shape[2], pyramid_map, num_classes=81, base_anchors=9, is_training=True, gt_boxes=gt_boxes, gt_masks=gt_masks, loss_weights=[0.2, 0.2, 1.0, 0.2, 1.0]) total_loss = outputs['total_loss'] losses = outputs['losses'] batch_info = outputs['batch_info'] regular_loss = tf.add_n( tf.get_collection(tf.GraphKeys.REGULARIZATION_LOSSES)) input_image = end_points['input'] final_box = outputs['final_boxes']['box'] final_cls = outputs['final_boxes']['cls'] final_prob = outputs['final_boxes']['prob'] final_gt_cls = outputs['final_boxes']['gt_cls'] gt = outputs['gt'] ############################# tmp_0 = outputs['losses'] tmp_1 = outputs['losses'] tmp_2 = outputs['losses'] tmp_3 = outputs['losses'] tmp_4 = outputs['losses'] # tmp_0 = outputs['tmp_0'] # tmp_1 = outputs['tmp_1'] # tmp_2 = outputs['tmp_2'] tmp_3 = outputs['tmp_3'] tmp_4 = outputs['tmp_4'] ############################ ## solvers global_step = slim.create_global_step() update_op = solve(global_step) cropped_rois = tf.get_collection('__CROPPED__')[0] transposed = tf.get_collection('__TRANSPOSED__')[0] gpu_options = tf.GPUOptions(per_process_gpu_memory_fraction=0.95) sess = tf.Session(config=tf.ConfigProto(gpu_options=gpu_options)) init_op = tf.group(tf.global_variables_initializer(), tf.local_variables_initializer()) sess.run(init_op) summary_op = tf.summary.merge_all() logdir = os.path.join(FLAGS.train_dir, strftime('%Y%m%d%H%M%S', gmtime())) if not os.path.exists(logdir): os.makedirs(logdir) summary_writer = tf.summary.FileWriter(logdir, graph=sess.graph) ## restore restore(sess) ## main loop coord = tf.train.Coordinator() threads = [] # print (tf.get_collection(tf.GraphKeys.QUEUE_RUNNERS)) for qr in tf.get_collection(tf.GraphKeys.QUEUE_RUNNERS): threads.extend( qr.create_threads(sess, coord=coord, daemon=True, start=True)) tf.train.start_queue_runners(sess=sess, coord=coord) saver = tf.train.Saver(max_to_keep=20) for step in range(FLAGS.max_iters): start_time = time.time() s_, tot_loss, reg_lossnp, img_id_str, \ rpn_box_loss, rpn_cls_loss, refined_box_loss, refined_cls_loss, mask_loss, \ gt_boxesnp, \ rpn_batch_pos, rpn_batch, refine_batch_pos, refine_batch, mask_batch_pos, mask_batch, \ input_imagenp, final_boxnp, final_clsnp, final_probnp, final_gt_clsnp, gtnp, tmp_0np, tmp_1np, tmp_2np, tmp_3np, tmp_4np= \ sess.run([update_op, total_loss, regular_loss, img_id] + losses + [gt_boxes] + batch_info + [input_image] + [final_box] + [final_cls] + [final_prob] + [final_gt_cls] + [gt] + [tmp_0] + [tmp_1] + [tmp_2] + [tmp_3] + [tmp_4]) duration_time = time.time() - start_time if step % 1 == 0: print( """iter %d: image-id:%07d, time:%.3f(sec), regular_loss: %.6f, """ """total-loss %.4f(%.4f, %.4f, %.6f, %.4f, %.4f), """ """instances: %d, """ """batch:(%d|%d, %d|%d, %d|%d)""" % (step, img_id_str, duration_time, reg_lossnp, tot_loss, rpn_box_loss, rpn_cls_loss, refined_box_loss, refined_cls_loss, mask_loss, gt_boxesnp.shape[0], rpn_batch_pos, rpn_batch, refine_batch_pos, refine_batch, mask_batch_pos, mask_batch)) # draw_bbox(step, # np.uint8((np.array(input_imagenp[0])/2.0+0.5)*255.0), # name='est', # bbox=final_boxnp, # label=final_clsnp, # prob=final_probnp, # gt_label=np.argmax(np.asarray(final_gt_clsnp),axis=1), # ) # draw_bbox(step, # np.uint8((np.array(input_imagenp[0])/2.0+0.5)*255.0), # name='gt', # bbox=gtnp[:,0:4], # label=np.asarray(gtnp[:,4], dtype=np.uint8), # ) print("labels") # print (cat_id_to_cls_name(np.unique(np.argmax(np.asarray(final_gt_clsnp),axis=1)))[1:]) # print (cat_id_to_cls_name(np.unique(np.asarray(gt_boxesnp, dtype=np.uint8)[:,4]))) print( cat_id_to_cls_name( np.unique(np.argmax(np.asarray(tmp_3np), axis=1)))[1:]) #print (cat_id_to_cls_name(np.unique(np.argmax(np.asarray(gt_boxesnp)[:,4],axis=1)))) print("classes") print( cat_id_to_cls_name( np.unique(np.argmax(np.array(tmp_4np), axis=1)))) # print (np.asanyarray(tmp_3np)) #print ("ordered rois") #print (np.asarray(tmp_0np)[0]) #print ("pyramid_feature") #print () #print(np.unique(np.argmax(np.array(final_probnp),axis=1))) #for var, val in zip(tmp_2, tmp_2np): # print(var.name) #print(np.argmax(np.array(tmp_0np),axis=1)) if np.isnan(tot_loss) or np.isinf(tot_loss): print(gt_boxesnp) raise if step % 100 == 0: summary_str = sess.run(summary_op) summary_writer.add_summary(summary_str, step) summary_writer.flush() if (step % 10000 == 0 or step + 1 == FLAGS.max_iters) and step != 0: checkpoint_path = os.path.join( FLAGS.train_dir, FLAGS.dataset_name + '_' + FLAGS.network + '_model.ckpt') saver.save(sess, checkpoint_path, global_step=step) if coord.should_stop(): coord.request_stop() coord.join(threads)
def style_image_inputs(style_dataset_file, batch_size=None, image_size=None, square_crop=False, shuffle=True): """Loads a style image at random. Args: style_dataset_file: str, path to the tfrecord dataset of style files. The dataset is produced via the create_style_dataset.py script and is made of Example protobufs with the following features: * 'image_raw': byte encoding of the JPEG string of the style image. * 'label': integer identifier of the style image in [0, N - 1], where N is the number of examples in the dataset. * 'vgg_16/<LAYER_NAME>': Gram matrix at layer <LAYER_NAME> of the VGG-16 network (<LAYER_NAME> in {conv,pool}{1,2,3,4,5}) for the style image. batch_size: int. If provided, batches style images. Defaults to None. image_size: int. The images will be resized bilinearly so that the smallest side has size image_size. Defaults to None. square_crop: bool. If True, square-crops to [image_size, image_size]. Defaults to False. shuffle: bool, whether to shuffle style files at random. Defaults to True. Returns: If batch_size is defined, a 4-D tensor of shape [batch_size, ?, ?, 3] with values in [0, 1] for the style image, and 1-D tensor for the style label. Raises: ValueError: if center cropping is requested but no image size is provided, or if batch size is specified but center-cropping is not requested. """ vgg_layers = ['vgg_16/conv1', 'vgg_16/pool1', 'vgg_16/conv2', 'vgg_16/pool2', 'vgg_16/conv3', 'vgg_16/pool3', 'vgg_16/conv4', 'vgg_16/pool4', 'vgg_16/conv5', 'vgg_16/pool5'] if square_crop and image_size is None: raise ValueError('center-cropping requires specifying the image size.') if batch_size is not None and not square_crop: raise ValueError('batching requires center-cropping.') with tf.name_scope('style_image_processing'): filename_queue = tf.train.string_input_producer( [style_dataset_file], shuffle=False, capacity=1, name='filename_queue') if shuffle: examples_queue = tf.RandomShuffleQueue( capacity=64, min_after_dequeue=32, dtypes=[tf.string], name='random_examples_queue') else: examples_queue = tf.FIFOQueue( capacity=64, dtypes=[tf.string], name='fifo_examples_queue') reader = tf.TFRecordReader() _, value = reader.read(filename_queue) enqueue_ops = [examples_queue.enqueue([value])] tf.train.queue_runner.add_queue_runner( tf.train.queue_runner.QueueRunner(examples_queue, enqueue_ops)) example_serialized = examples_queue.dequeue() features = tf.parse_single_example( example_serialized, features={'label': tf.FixedLenFeature([], tf.int64), 'image_raw': tf.FixedLenFeature([], tf.string), 'vgg_16/conv1': tf.FixedLenFeature([64, 64], tf.float32), 'vgg_16/pool1': tf.FixedLenFeature([64, 64], tf.float32), 'vgg_16/conv2': tf.FixedLenFeature([128, 128], tf.float32), 'vgg_16/pool2': tf.FixedLenFeature([128, 128], tf.float32), 'vgg_16/conv3': tf.FixedLenFeature([256, 256], tf.float32), 'vgg_16/pool3': tf.FixedLenFeature([256, 256], tf.float32), 'vgg_16/conv4': tf.FixedLenFeature([512, 512], tf.float32), 'vgg_16/pool4': tf.FixedLenFeature([512, 512], tf.float32), 'vgg_16/conv5': tf.FixedLenFeature([512, 512], tf.float32), 'vgg_16/pool5': tf.FixedLenFeature([512, 512], tf.float32)}) image = tf.image.decode_jpeg(features['image_raw']) label = features['label'] gram_matrices = [features[vgg_layer] for vgg_layer in vgg_layers] image.set_shape([None, None, 3]) if image_size: if square_crop: image = _aspect_preserving_resize(image, image_size + 2) image = _central_crop([image], image_size, image_size)[0] image.set_shape([image_size, image_size, 3]) else: image = _aspect_preserving_resize(image, image_size) image = tf.to_float(image) / 255.0 if batch_size is None: image = tf.expand_dims(image, 0) else: image_label_gram_matrices = tf.train.batch( [image, label] + gram_matrices, batch_size=batch_size) image, label = image_label_gram_matrices[:2] gram_matrices = image_label_gram_matrices[2:] gram_matrices = dict([(vgg_layer, gram_matrix) for vgg_layer, gram_matrix in zip(vgg_layers, gram_matrices)]) return image, label, gram_matrices
def get_batch_input_tensors(self): with tf.name_scope('batch_processing'): data_files = self.dataset.data_files() if data_files is None: raise ValueError('No data files found for this dataset') # Create filename_queue if self.mode == 'train' or self.need_shuffle: filename_queue = tf.train.string_input_producer(data_files, shuffle=True, capacity=16) else: filename_queue = tf.train.string_input_producer(data_files, shuffle=False, capacity=1) if self.num_preprocess_threads % 2: raise ValueError('Please make num_preprocess_threads a multiple ' 'of 2 (%d % 2 != 0).', self.num_preprocess_threads) if self.num_readers < 1: raise ValueError('Please make num_readers at least 1') # Approximate number of examples per shard. examples_per_shard = 1024 # Size the random shuffle queue to balance between good global # mixing (more examples) and memory use (fewer examples). # 1 image uses 299*299*3*4 bytes = 1MB # The default input_queue_memory_factor is 16 implying a shuffling queue # size: examples_per_shard * 16 * 1MB = 17.6GB min_queue_examples = examples_per_shard * INPUT_QUEUE_MEMORY_FACTOR if self.mode == 'train' or self.need_shuffle: print('use random shuffle example queue') examples_queue = tf.RandomShuffleQueue( capacity=min_queue_examples + 3 * self.batch_size, min_after_dequeue=min_queue_examples, dtypes=[tf.string]) else: print('use FIFO example queue') examples_queue = tf.FIFOQueue( capacity=examples_per_shard + 3 * self.batch_size, dtypes=[tf.string]) # Create multiple readers to populate the queue of examples. if self.num_readers > 1: enqueue_ops = [] for _ in range(self.num_readers): reader = self.dataset.reader() _, value = reader.read(filename_queue) enqueue_ops.append(examples_queue.enqueue([value])) tf.train.queue_runner.add_queue_runner( tf.train.queue_runner.QueueRunner(examples_queue, enqueue_ops)) example_serialized = examples_queue.dequeue() else: reader = self.dataset.reader() _, example_serialized = reader.read(filename_queue) images_and_labels = [] for thread_id in range(self.num_preprocess_threads): # Parse a serialized Example proto to extract the image and metadata. image, label_index = self.cifar10_parse_example_proto(example_serialized) # image = self.cifar10_preprocess(image_buffer) images_and_labels.append([image, label_index]) images, label_index_batch = tf.train.batch_join( images_and_labels, batch_size=self.batch_size, capacity=2 * self.num_preprocess_threads * self.batch_size) # Reshape images into these desired dimensions. height = self.image_size width = self.image_size depth = 3 images = tf.cast(images, tf.float32) images = tf.reshape(images, shape=[self.batch_size, height, width, depth]) # Display the training images in the visualizer. tf.summary.image('images', images) return images, tf.reshape(label_index_batch, [self.batch_size])
def imagenet_inputs(batch_size, image_size, num_readers=1, num_preprocess_threads=4): """Loads a batch of imagenet inputs. Used as a replacement for inception.image_processing.inputs in tensorflow/models in order to get around the use of hard-coded flags in the image_processing module. Args: batch_size: int, batch size. image_size: int. The images will be resized bilinearly to shape [image_size, image_size]. num_readers: int, number of preprocessing threads per tower. Must be a multiple of 4. num_preprocess_threads: int, number of parallel readers. Returns: 4-D tensor of images of shape [batch_size, image_size, image_size, 3], with values in [0, 1]. Raises: IOError: If ImageNet data files cannot be found. ValueError: If `num_preprocess_threads is not a multiple of 4 or `num_readers` is less than 1. """ imagenet = imagenet_data.ImagenetData('train') with tf.name_scope('batch_processing'): data_files = imagenet.data_files() if data_files is None: raise IOError('No ImageNet data files found') # Create filename_queue. filename_queue = tf.train.string_input_producer(data_files, shuffle=True, capacity=16) if num_preprocess_threads % 4: raise ValueError('Please make num_preprocess_threads a multiple ' 'of 4 (%d % 4 != 0).', num_preprocess_threads) if num_readers < 1: raise ValueError('Please make num_readers at least 1') # Approximate number of examples per shard. examples_per_shard = 1024 # Size the random shuffle queue to balance between good global # mixing (more examples) and memory use (fewer examples). # 1 image uses 299*299*3*4 bytes = 1MB # The default input_queue_memory_factor is 16 implying a shuffling queue # size: examples_per_shard * 16 * 1MB = 17.6GB input_queue_memory_factor = 16 min_queue_examples = examples_per_shard * input_queue_memory_factor examples_queue = tf.RandomShuffleQueue( capacity=min_queue_examples + 3 * batch_size, min_after_dequeue=min_queue_examples, dtypes=[tf.string]) # Create multiple readers to populate the queue of examples. if num_readers > 1: enqueue_ops = [] for _ in range(num_readers): reader = imagenet.reader() _, value = reader.read(filename_queue) enqueue_ops.append(examples_queue.enqueue([value])) tf.train.queue_runner.add_queue_runner( tf.train.queue_runner.QueueRunner(examples_queue, enqueue_ops)) example_serialized = examples_queue.dequeue() else: reader = imagenet.reader() _, example_serialized = reader.read(filename_queue) images_and_labels = [] for _ in range(num_preprocess_threads): # Parse a serialized Example proto to extract the image and metadata. image_buffer, label_index, _, _ = _parse_example_proto( example_serialized) image = _decode_jpeg(image_buffer) # pylint: disable=protected-access image = _aspect_preserving_resize(image, image_size + 2) image = _central_crop([image], image_size, image_size)[0] # pylint: enable=protected-access image.set_shape([image_size, image_size, 3]) image = tf.to_float(image) / 255.0 images_and_labels.append([image, label_index]) images, label_index_batch = tf.train.batch_join( images_and_labels, batch_size=batch_size, capacity=2 * num_preprocess_threads * batch_size) images = tf.reshape(images, shape=[batch_size, image_size, image_size, 3]) # Display the training images in the visualizer. tf.image_summary('images', images) return images, tf.reshape(label_index_batch, [batch_size])
def batch_inputs(dataset, batch_size, train, num_preprocess_threads=None, num_readers=1): """Contruct batches of training or evaluation examples from the image dataset. Args: dataset: instance of Dataset class specifying the dataset. See dataset.py for details. batch_size: integer train: boolean num_preprocess_threads: integer, total number of preprocessing threads num_readers: integer, number of parallel readers Returns: images: 4-D float Tensor of a batch of images labels: 1-D integer Tensor of [batch_size]. Raises: ValueError: if data is not found """ with tf.name_scope('batch_processing'): data_files = dataset.data_files() if data_files is None: raise ValueError('No data files found for this dataset') # Create filename_queue if train: filename_queue = tf.train.string_input_producer(data_files, shuffle=True, capacity=64) else: filename_queue = tf.train.string_input_producer(data_files, shuffle=False, capacity=1) if num_preprocess_threads is None: num_preprocess_threads = FLAGS.num_preprocess_threads # to reduce the num of preprocessing threads, no longer require this #if num_preprocess_threads % 4: # raise ValueError('Please make num_preprocess_threads a multiple ' # 'of 4 (%d % 4 != 0).', num_preprocess_threads) if num_readers is None: num_readers = FLAGS.num_readers if num_readers < 1: raise ValueError('Please make num_readers at least 1') # Approximate number of examples per shard. examples_per_shard = FLAGS.examples_per_shard # Size the random shuffle queue to balance between good global # mixing (more examples) and memory use (fewer examples). # 1 image uses 299*299*3*4 bytes = 1MB # The default input_queue_memory_factor is 16 implying a shuffling queue # size: examples_per_shard * 16 * 1MB = 17.6GB if train: min_queue_examples = examples_per_shard * FLAGS.input_queue_memory_factor examples_queue = tf.RandomShuffleQueue( capacity=min_queue_examples + 3 * batch_size, min_after_dequeue=min_queue_examples, dtypes=[tf.string]) else: examples_queue = tf.FIFOQueue(capacity=examples_per_shard + 3 * batch_size, dtypes=[tf.string]) # Create multiple readers to populate the queue of examples. if num_readers > 1: enqueue_ops = [] for _ in range(num_readers): reader = dataset.reader() _, value = reader.read(filename_queue) enqueue_ops.append(examples_queue.enqueue([value])) tf.train.queue_runner.add_queue_runner( tf.train.queue_runner.QueueRunner(examples_queue, enqueue_ops)) example_serialized = examples_queue.dequeue() else: reader = dataset.reader() _, example_serialized = reader.read(filename_queue) if FLAGS.use_MIMO_inputs_pipeline: # The new convention for images and labels is a generalized one # images: all inputs; labels: all outputs that needs to be predicted datan = [] for thread_id in range(num_preprocess_threads): # 1. this function returns multiple input data (could include both labels and images). # This will enable more complex models such as LRCN with egomotion inputs to be able # to run with this framework # 2. The parse_example_proto function could return more than 1 input for one # example_serialized. # 3. the returned format is a list of tensors [Tensor1, Tensor2,...., Tensor_n], # each of the tensor denotes a small batch of one variable. # The tensors for the video might be 5-dim, [batch_size, nframes, H, W, C] # 4. We expect future data augmentation code to appear in parse_example_proto # itself, since inheriently the augmentation is highly dataset dependent. # 5. the parse_example_proto return net_input and net_output as two seperate tensor lists net_inputs, net_outputs = dataset.parse_example_proto( example_serialized) net_inputs, net_outputs = dataset.augmentation( train, net_inputs, net_outputs) datan.append(net_inputs + net_outputs) # the single thread batch_join dequeue_many operation might be the bottleneck. if net_inputs[0].get_shape()[0].value == batch_size: print( "output batch of parse_example_proto == required batchsize (%d), no batching needed" % batch_size) print("Omitting the batch_join queue") joins = datan one_joined = datan[-1] else: # this is quite slow, avoid using this joins = [] for i in range(FLAGS.num_batch_join): reduced_factor = max( math.ceil(1.0 * num_preprocess_threads / FLAGS.num_batch_join), 2) one_joined = tf.train.batch_join(tensors_list=datan, batch_size=batch_size, capacity=reduced_factor * batch_size, enqueue_many=True) joins.append(one_joined) print(FLAGS.num_batch_join, " batch_joins, each of them capacity is, ", reduced_factor * batch_size, " instances") # add a buffering queue to remove the dequeue_many time print("buffer queue capacity is: ", FLAGS.num_batch_join, " batches") capacity = FLAGS.num_batch_join buffer_queue = tf.FIFOQueue( capacity=capacity, dtypes=[x.dtype for x in one_joined], shapes=[x.get_shape() for x in one_joined], name="buffer_queue") tf.summary.scalar( "queue/%s/fraction_of_%d_full" % (buffer_queue.name, capacity), tf.cast(buffer_queue.size(), tf.float32) * (1. / capacity)) buffer_ops = [buffer_queue.enqueue(join) for join in joins] tf.train.queue_runner.add_queue_runner( tf.train.queue_runner.QueueRunner(buffer_queue, buffer_ops)) data_joined = buffer_queue.dequeue() # end of buffer queue # The CPU to GPU memory transfer still not resolved # recover the inputs and outputs joined_inputs = data_joined[:len(net_inputs)] joined_outputs = data_joined[len(net_inputs):] # dataset's visualizer # since only the dataset knows how to visualize the data, let the dataset to provide such method dataset.visualize(joined_inputs, joined_outputs) return joined_inputs, joined_outputs else: raise ValueError("have to use MIMO input pipeline")
def build_input(dataset, batch_size, mode): if mode == 'train': data_path = '../cifar10/data_batch*' elif mode == 'test': data_path = '../cifar10/test_batch.bin' tf.set_random_seed(2) image_size = 32 if dataset == 'cifar10': label_bytes = 1 label_offset = 0 num_classes = 10 elif dataset == 'cifar100': label_bytes = 1 label_offset = 1 num_classes = 100 else: raise ValueError('Not supported dataset %s', dataset) depth = 3 image_bytes = image_size * image_size * depth record_bytes = label_bytes + label_offset + image_bytes data_files = tf.gfile.Glob(data_path) file_queue = tf.train.string_input_producer(data_files, shuffle=True) # Read examples from files in the filename queue. reader = tf.FixedLengthRecordReader(record_bytes=record_bytes) _, value = reader.read(file_queue) # Convert these examples to dense labels and processed images. record = tf.reshape(tf.decode_raw(value, tf.uint8), [record_bytes]) label = tf.cast(tf.slice(record, [label_offset], [label_bytes]), tf.int32) # Convert from string to [depth * height * width] to [depth, height, width]. depth_major = tf.reshape(tf.slice(record, [label_offset + label_bytes], [image_bytes]), [depth, image_size, image_size]) # Convert from [depth, height, width] to [height, width, depth]. image = tf.cast(tf.transpose(depth_major, [1, 2, 0]), tf.float32) if mode == 'train': image = tf.image.resize_image_with_crop_or_pad( image, image_size+4, image_size+4) image = tf.random_crop(image, [image_size, image_size, 3], seed=3) image = tf.image.random_flip_left_right(image, seed=5) # Brightness/saturation/constrast provides small gains .2%~.5% on cifar. # image = tf.image.random_brightness(image, max_delta=63. / 255.) # image = tf.image.random_saturation(image, lower=0.5, upper=1.5) # image = tf.image.random_contrast(image, lower=0.2, upper=1.8) image = tf.image.per_image_standardization(image) example_queue = tf.RandomShuffleQueue( capacity=16 * batch_size, min_after_dequeue=8 * batch_size, dtypes=[tf.float32, tf.int32], shapes=[[image_size, image_size, depth], [1]], seed=7) num_threads = 16 else: image = tf.image.resize_image_with_crop_or_pad( image, image_size, image_size) image = tf.image.per_image_standardization(image) example_queue = tf.FIFOQueue( 3 * batch_size, dtypes=[tf.float32, tf.int32], shapes=[[image_size, image_size, depth], [1]]) num_threads = 1 example_enqueue_op = example_queue.enqueue([image, label]) tf.train.add_queue_runner(tf.train.queue_runner.QueueRunner( example_queue, [example_enqueue_op] * num_threads)) # Read 'batch' labels + images from the example queue. images, labels = example_queue.dequeue_many(batch_size) labels = tf.squeeze(labels) assert len(images.get_shape()) == 4 assert images.get_shape()[0] == batch_size assert images.get_shape()[-1] == 3 assert len(labels.get_shape()) == 1 # Display the training images in the visualizer. tf.summary.image('images', images) return images, labels