def test(): filename_queue = tf.train.string_input_producer([tfrecord_filename]) data_array, target_array = reader.read_and_decode(filename_queue, shuffle_batch=False) with tf.device('/gpu:0'): global_step = slim.create_global_step() with tf.device('/cpu:0'): lrn_rate = tf.train.exponential_decay(FLAGS.learning_rate, global_step, 5000, 0.917, staircase=True) tf.summary.scalar('learning_rate', lrn_rate) with tf.device('/gpu:0'): # tf.train.exponential_decay( # FLAGS.learning_rate, global_step, 5000, 0.92, staircase=True) # visualizing learning # tf.summary.scalar('learning_rate', lrn_rate) optimizer = tf.train.AdamOptimizer(lrn_rate) # data = tf.placeholder(tf.float32, [FLAGS.batch_size, 32, 32, 32, 2]) # target = tf.placeholder(tf.float32, [FLAGS.batch_size, 32, 32, 32, 1]) ops = epn_test.model(input_data=data_array) loss, mask = losses.get_l1_loss(input_data=data_array, pre_data=ops, label=target_array) # tf.summary.scalar('loss_function', loss) # train_step = optimizer.minimize(loss=loss, global_step=global_step) with tf.device('/cpu:0'): tf.summary.scalar('loss_function', loss) saver = tf.train.Saver() with tf.Session() as sess: sess.run(tf.global_variables_initializer()) saver.restore(sess, model_path) coord = tf.train.Coordinator() threads = tf.train.start_queue_runners(sess=sess, coord=coord) loss_value_total = 0.0 for i in range(1): loss_value_total = loss_value_total + sess.run(loss) data_origin, pre_origin, target_origin = sess.run( [data_array, ops, target_array]) # loss_value_total=tf.concat([loss_value_total,loss_value],axis=0) print str(i) + 'step' # print type(loss_value) print 'loss_mean=' + str(loss_value_total) # input = tf.reshape(data_array[:, :, :, :, 0], [32, 32, 32]) # pre = tf.subtract(tf.exp(pre), tf.constant(1, tf.float32)) # pre = tf.reshape(pre, [32, 32, 32]) # target = tf.subtract(tf.exp(target_array), tf.constant(1, tf.float32)) # target = tf.reshape(target, [32, 32, 32]) input = np.reshape(data_origin[:, :, :, :, 0], (32, 32, 32)) pre = np.exp(pre_origin) - 1 pre = np.reshape(pre, [32, 32, 32]) target = np.exp(target_origin) - 1 target = np.reshape(target, [32, 32, 32]) outprefix = os.path.join(FLAGS.output_path, 'sample_') export_prediction_to_mesh(outprefix, input, pre, target) coord.request_stop() coord.join(threads)
def inputs(filename, batch_size, num_epochs2, num_threads, imshape, num_examples_per_epoch=128): """Reads input tfrecord file num_epochs times. Use it for validation. Args: filename: The path to the .tfrecords file to be read batch_size: Number of examples per returned batch. num_epochs: Number of times to read the input ckpt, or 0/None to train forever. num_threads: Number of reader workers to enqueue imshape: The shape of image in the format num_examples_per_epoch: Number of images to use per epoch Returns: A tuple (images, labels), where: * images is a float tensor with shape [batch_size, mnist.IMAGE_PIXELS] in the range [-0.5, 0.5]. * labels is an int32 tensor with shape [batch_size] with the true label, a number in the range [0, mnist.NUM_CLASSES). Note that an tf.train.QueueRunner is added to the graph, which must be run using e.g. tf.train.start_queue_runners(). """ tf.local_variables_initializer() if not num_epochs2: num_epochs2 = None with tf.name_scope('input'): filename_queue = tf.train.string_input_producer( [filename], num_epochs=num_epochs2, name='string_input_producer') # Even when reading in multiple threads, share the filename # queue. #image, label = reader.read_and_decode(filename_queue, imshape, normalize=True, flatten=False) image, label = reader.read_and_decode(filename_queue, imshape, normalize=True) # Convert from [0, 255] -> [-0.5, 0.5] floats. The normalize param in read_and_decode will do the same job. # image = tf.cast(image, tf.float32) # image = tf.cast(image, tf.float32) * (1. / 255) - 0.5 # Shuffle the examples and collect them into batch_size batches. # (Internally uses a RandomShuffleQueue.) # We run this in two threads to avoid being a bottleneck. # Ensure that the random shuffling has good mixing properties. min_fraction_of_examples_in_queue = 0.4 min_queue_examples = int(num_examples_per_epoch * min_fraction_of_examples_in_queue) images, sparse_labels = tf.train.shuffle_batch( [image, label], batch_size=batch_size, num_threads=num_threads, capacity=min_queue_examples + 3 * batch_size, enqueue_many=False, # Ensures a minimum amount of shuffling of examples. min_after_dequeue=min_queue_examples, name='batching_shuffling') return images, sparse_labels
def build_model(self): if F.use_tfrecords == True: # load images from tfrecords + queue thread runner for better GPU utilization tfrecords_filename = ['train_data/' + x for x in os.listdir('train_data/')] filename_queue = tf.train.string_input_producer( tfrecords_filename, num_epochs=100) self.images, _ = reader.read_and_decode(filename_queue, F.batch_size) if F.output_size == 64: self.images = tf.image.resize_images(self.images, (64, 64)) self.images = (self.images / 127.5) - 1 else: self.images = tf.placeholder(tf.float32, [F.batch_size, F.output_size, F.output_size, F.c_dim], name='real_images') self.z_gen = tf.placeholder(tf.float32, [None, F.z_dim], name='z') self.G_mean = self.generator(self.z_gen) self.D, self.D_logits = self.discriminator(self.images, reuse=False) self.D_, self.D_logits_, = self.discriminator(self.G_mean, reuse=True) #calculations for getting hard predictions # +1 means fooled the D network while -1 mean D has won self.d_loss_real = tf.reduce_mean( tf.nn.sigmoid_cross_entropy_with_logits(logits = self.D_logits, labels = tf.ones_like(self.D))) self.d_loss_fake = tf.reduce_mean( tf.nn.sigmoid_cross_entropy_with_logits(logits = self.D_logits_, labels = tf.zeros_like(self.D_))) self.d_loss = self.d_loss_real + self.d_loss_fake self.g_loss_actual = tf.reduce_mean( tf.nn.sigmoid_cross_entropy_with_logits(logits = self.D_logits_, labels = tf.ones_like(self.D_))) self.g_loss = tf.constant(0) self.output = self.generator(self.images_i) self.mse_loss = if F.error_conceal == True: self.mask = tf.placeholder(tf.float32, [F.batch_size] + self.image_shape, name='mask') self.contextual_loss = tf.reduce_sum( tf.contrib.layers.flatten( tf.abs(tf.multiply(self.mask, self.G_mean) - tf.multiply(self.mask, self.images))), 1) self.perceptual_loss = self.g_loss_actual self.complete_loss = self.contextual_loss + F.lam * self.perceptual_loss self.grad_complete_loss = tf.gradients(self.complete_loss, self.z_gen) t_vars = tf.trainable_variables() self.d_vars = [var for var in t_vars if 'd_' in var.name] self.g_vars = [var for var in t_vars if 'g_' in var.name] self.saver = tf.train.Saver()
def inputs(filename, batch_size, num_epochs, num_threads, imshape, num_examples_per_epoch=128): """Reads input tfrecord file num_epochs times. Use it for validation. Args: filename: The path to the .tfrecords file to be read batch_size: Number of examples per returned batch. num_epochs: Number of times to read the input ckpt, or 0/None to train forever. num_threads: Number of reader workers to enqueue imshape: The shape of image in the format num_examples_per_epoch: Returns: A tuple (images, labels), where: * images is a float tensor with shape [batch_size, mnist.IMAGE_PIXELS] in the range [-0.5, 0.5]. * labels is an int32 tensor with shape [batch_size] with the true label, a number in the range [0, mnist.NUM_CLASSES). Note that an tf.train.QueueRunner is added to the graph, which must be run using e.g. tf.train.start_queue_runners(). """ if not num_epochs: num_epochs = None with tf.name_scope("input"): filename_queue = tf.train.string_input_producer([filename], num_epochs=num_epochs, name="string_input_producer") # Even when reading in multiple threads, share the filename # queue. image, label = reader.read_and_decode(filename_queue, imshape, normalize=True) # Convert from [0, 255] -> [-0.5, 0.5] floats. The normalize param in read_and_decode will do the same job. # image = tf.cast(image, tf.float32) # image = tf.cast(image, tf.float32) * (1. / 255) - 0.5 # Shuffle the examples and collect them into batch_size batches. # (Internally uses a RandomShuffleQueue.) # We run this in two threads to avoid being a bottleneck. # Ensure that the random shuffling has good mixing properties. min_fraction_of_examples_in_queue = 0.4 min_queue_examples = int(num_examples_per_epoch * min_fraction_of_examples_in_queue) images, sparse_labels = tf.train.shuffle_batch( [image, label], batch_size=batch_size, num_threads=num_threads, capacity=min_queue_examples + 3 * batch_size, enqueue_many=False, # Ensures a minimum amount of shuffling of examples. min_after_dequeue=min_queue_examples, name="batching_shuffling", ) return images, sparse_labels
def train(): filename_queue = tf.train.string_input_producer([tfrecord_filename]) data_array, target_array = reader.read_and_decode(filename_queue) with tf.device('/gpu:0'): global_step = slim.create_global_step() with tf.device('/cpu:0'): lrn_rate = tf.train.exponential_decay(FLAGS.learning_rate, global_step, 5000, 0.917, staircase=True) tf.summary.scalar('learning_rate', lrn_rate) with tf.device('/gpu:0'): optimizer = tf.train.AdamOptimizer(lrn_rate) # data = tf.placeholder(tf.float32, [FLAGS.batch_size, 32, 32, 32, 2]) # target = tf.placeholder(tf.float32, [FLAGS.batch_size, 32, 32, 32, 1]) ops = epn.model(input_data=data_array) loss, mask = losses.get_l1_loss(input_data=data_array, pre_data=ops, label=target_array) train_step = optimizer.minimize(loss=loss, global_step=global_step) with tf.device('/cpu:0'): tf.summary.scalar('loss_function', loss) #saver = tf.train.Saver() # print target_array[0][0][0][0][0] # sess = tf.Session(config=tf.ConfigProto(allow_soft_placement=True, log_device_placement=True)) # print loss.get_shape().as_list() with tf.Session() as sess: sess.run(tf.local_variables_initializer()) sess.run(tf.global_variables_initializer()) merged_summary_op = tf.summary.merge_all() summary_writer = tf.summary.FileWriter( '/home/zzxmllq/h5_shapenet_dim32_sdf/h5_shapenet_dim32_sdf', sess.graph) coord = tf.train.Coordinator() threads = tf.train.start_queue_runners(sess=sess, coord=coord) # for j in range(FLAGS.max_epoch): for j in range(FLAGS.max_epoch): for i in range(2000): _, loss_value, mask_v = sess.run([train_step, loss, mask]) print str(j + 1) + ' epoch' + ' ' + str( i) + ' minibatch' + ':' + str(loss_value) if i % 10 == 0: summary_str = sess.run(merged_summary_op) summary_writer.add_summary(summary_str, j * 2000 + i) #save_path=saver.save(sess,model_path) #print("Model saved in file:%s"% save_path) coord.request_stop() coord.join(threads)
def train(): filename_queue = tf.train.string_input_producer([tfrecord_filename]) images, labels = reader.read_and_decode(filename_queue=filename_queue, batch_size=FLAGS.batch_size) with tf.device('/gpu:0'): global_step = slim.create_global_step() with tf.device('/cpu:0'): num_batches_per_epoch = FLAGS.data_size / FLAGS.batch_size decay_steps = int(num_batches_per_epoch * NUM_EPOCHS_PER_DECAY) lrn_rate = tf.train.exponential_decay(FLAGS.learning_rate, global_step, decay_steps, LEARNING_RATE_DECAY_FACTOR, staircase=True) with tf.device('/gpu:0'): fc8 = alexnet.model(input_data=images, n_classes=FLAGS.n_classes, keep_prob=FLAGS.keep_prob) total_loss = loss.get_loss(input_data=fc8, grdtruth=labels) loss_averages = tf.train.ExponentialMovingAverage(0.9, name='avg') losses = tf.get_collection('losses') loss_averages_op = loss_averages.apply(losses + [total_loss]) with tf.control_dependencies([loss_averages_op]): optimizer = tf.train.AdamOptimizer(lrn_rate) train_step = optimizer.minimize(loss=total_loss, global_step=global_step) variable_averages = tf.train.ExponentialMovingAverage( MOVING_AVERAGE_DECAY, global_step) variable_averages_op = variable_averages.apply( tf.trainable_variables()) with tf.control_dependencies([train_step, variable_averages_op]): train_step = tf.no_op(name='train') prediction = alexnet.classify(fc8) with tf.Session() as sess: sess.run(tf.local_variables_initializer()) sess.run(tf.global_variables_initializer()) coord = tf.train.Coordinator() threads = tf.train.start_queue_runners(sess=sess, coord=coord) for j in range(FLAGS.max_epoch): for i in range(200): _, loss_value, pre, grd = sess.run( [train_step, total_loss, prediction, labels]) print str(j + 1) + ' epoch' + ' ' + str( i) + ' minibatch' + ':' + str(loss_value) print str(j + 1) + ' epoch' + ' ' + str( i) + ' minibatch' + ':' + str(pre) + " " + str(grd) coord.request_stop() coord.join(threads)
def train(): filename_queue = tf.train.string_input_producer([tfrecord_filename]) images, labels = reader.read_and_decode(filename_queue=filename_queue, batch_size=FLAGS.batch_size) with tf.device('/gpu:0'): global_step = slim.create_global_step() with tf.device('/cpu:0'): num_batches_per_epoch = FLAGS.data_size / FLAGS.batch_size decay_steps = int(num_batches_per_epoch * NUM_EPOCHS_PER_DECAY) lrn_rate = tf.train.exponential_decay(FLAGS.learning_rate, global_step, decay_steps, LEARNING_RATE_DECAY_FACTOR, staircase=True) config = tf.ConfigProto() config.gpu_options.per_process_gpu_memory_fraction = 0.6 with tf.device('/gpu:0'): optimizer = tf.train.AdamOptimizer(lrn_rate) fc8 = vgg_m.model(input_data=images, n_classes=FLAGS.n_classes, keep_prob=FLAGS.keep_prob) losses = loss.get_loss(input_data=fc8, grdtruth=labels) train_step = optimizer.minimize(loss=losses, global_step=global_step) prediction = vgg_m.classify(fc8) with tf.device('/cpu:0'): saver = tf.train.Saver() with tf.Session(config=config) as sess: sess.run(tf.local_variables_initializer()) sess.run(tf.global_variables_initializer()) coord = tf.train.Coordinator() threads = tf.train.start_queue_runners(sess=sess, coord=coord) for j in range(FLAGS.max_epoch): for i in range(200): _, loss_value, pre, grd = sess.run( [train_step, losses, prediction, labels]) print str(j + 1) + ' epoch' + ' ' + str( i) + ' minibatch' + ':' + str(loss_value) print str(j + 1) + ' epoch' + ' ' + str( i) + ' minibatch' + ':' + str(pre) + " " + str(grd) save_path = saver.save(sess, model_path) print("Model saved in file:%s" % save_path) coord.request_stop() coord.join(threads)
def test(): filename_queue = tf.train.string_input_producer([tfrecord_filename]) images, labels = reader.read_and_decode(filename_queue=filename_queue, batch_size=FLAGS.batch_size, shuffle_batch=False) # with tf.device('/gpu:0'): # global_step = slim.create_global_step() # with tf.device('/cpu:0'): # num_batches_per_epoch = FLAGS.data_size / FLAGS.batch_size # decay_steps = int(num_batches_per_epoch * NUM_EPOCHS_PER_DECAY) # lrn_rate = tf.train.exponential_decay( # FLAGS.learning_rate, global_step, decay_steps, LEARNING_RATE_DECAY_FACTOR, staircase=True) with tf.device('/gpu:0'): # optimizer = tf.train.AdamOptimizer(lrn_rate) fc8 = alexnet.model(input_data=images, n_classes=FLAGS.n_classes, keep_prob=FLAGS.keep_prob) losses = loss.get_loss(input_data=fc8, grdtruth=labels) # train_step = optimizer.minimize(loss=losses, global_step=global_step) prediction = alexnet.classify(fc8) with tf.device('/cpu:0'): saver = tf.train.Saver() with tf.Session() as sess: sess.run(tf.local_variables_initializer()) sess.run(tf.global_variables_initializer()) saver.restore(sess, model_path) coord = tf.train.Coordinator() threads = tf.train.start_queue_runners(sess=sess, coord=coord) total = 0.0 right = 0.0 for i in range(80): loss_value, pre, grd = sess.run([losses, prediction, labels]) print str(i + 1) + 'image loss :' + str(loss_value) print str(i + 1) + ' result:' + ':' + str(pre) + " " + str(grd) right += np.sum(np.equal(pre, grd)) total += 10 print 'accurcy:' + str(right / total) coord.request_stop() coord.join(threads)
def distorted_inputs(filename, batch_size, num_epochs, num_threads, imshape, imsize, num_examples_per_epoch=128): """Construct distorted input for training using the Reader ops. Raises: ValueError: if no data_dir Args: filename: batch_size: num_epochs: num_threads: imshape: imsize: num_examples_per_epoch: Returns: images: Images. 4D tensor of [batch_size, IMAGE_SIZE, IMAGE_SIZE, 3] size. labels: Labels. 1D tensor of [batch_size] size. """ if not num_epochs: num_epochs = None with tf.name_scope('input'): filename_queue = tf.train.string_input_producer( [filename], num_epochs=num_epochs, name='string_DISTORTED_input_producer') # Even when reading in multiple threads, share the filename # queue. image, label = reader.read_and_decode(filename_queue, imshape) # Reshape to [32, 32, 3] as distortion methods need this shape image = tf.reshape(image, imshape) height = imsize width = imsize # Image processing for training the network. Note the many random # distortions applied to the image. # Removed random_crop in new TensorFlow release. # Randomly crop a [height, width] section of the image. # distorted_image = tf.image.random_crop(image, [height, width]) # # Randomly flip the image horizontally. distorted_image = tf.image.random_flip_left_right(image) # # Because these operations are not commutative, consider randomizing # randomize the order their operation. distorted_image = tf.image.random_brightness(distorted_image, max_delta=63) distorted_image = tf.image.random_contrast(distorted_image, lower=0.2, upper=1.8) # # Subtract off the mean and divide by the variance of the pixels. float_image = tf.image.per_image_whitening(distorted_image) num_elements = 1 for i in imshape: num_elements = num_elements * i image = tf.reshape(float_image, [num_elements]) # Ensure that the random shuffling has good mixing properties. min_fraction_of_examples_in_queue = 0.4 min_queue_examples = int(num_examples_per_epoch * min_fraction_of_examples_in_queue) images, sparse_labels = tf.train.shuffle_batch( [image, label], batch_size=batch_size, num_threads=num_threads, capacity=min_queue_examples + 3 * batch_size, enqueue_many=False, # Ensures a minimum amount of shuffling of examples. min_after_dequeue=min_queue_examples, name='batching_shuffling_distortion') return images, sparse_labels
def build_model(self): # main method for training the conditional GAN if F.use_tfrecords == True: # load images from tfrecords + queue thread runner for better GPU utilization tfrecords_filename = [ 'train_records/' + x for x in os.listdir('train_records/') ] filename_queue = tf.train.string_input_producer(tfrecords_filename, num_epochs=100) self.images, self.keypoints = reader.read_and_decode( filename_queue, F.batch_size) if F.output_size == 64: self.images = tf.image.resize_images(self.images, (64, 64)) self.keypoints = tf.image.resize_images( self.keypoints, (64, 64)) self.images = (self.images / 127.5) - 1 self.keypoints = (self.keypoints / 127.5) - 1 else: self.images = tf.placeholder( tf.float32, [F.batch_size, F.output_size, F.output_size, F.c_dim], name='real_images') self.keypoints = tf.placeholder( tf.float32, [F.batch_size, F.output_size, F.output_size, F.c_dim], name='keypts') self.is_training = tf.placeholder(tf.bool, name='is_training') self.z_gen = tf.placeholder(tf.float32, [F.batch_size, F.z_dim], name='z') self.G = self.generator(self.z_gen, self.keypoints) self.D, self.D_logits = self.discriminator(self.images, self.keypoints, reuse=False) self.D_, self.D_logits_, = self.discriminator(self.G, self.keypoints, reuse=True) self.d_loss_real = tf.reduce_mean( tf.nn.sigmoid_cross_entropy_with_logits(logits=self.D_logits, labels=tf.ones_like( self.D))) self.d_loss_fake = tf.reduce_mean( tf.nn.sigmoid_cross_entropy_with_logits(logits=self.D_logits_, labels=tf.zeros_like( self.D_))) self.d_loss = self.d_loss_real + self.d_loss_fake self.g_loss_actual = tf.reduce_mean( tf.nn.sigmoid_cross_entropy_with_logits(logits=self.D_logits_, labels=tf.ones_like( self.D_))) if F.error_conceal == True: self.mask = tf.placeholder(tf.float32, [F.batch_size] + self.image_shape, name='mask') self.contextual_loss = tf.reduce_sum( tf.contrib.layers.flatten( tf.abs( tf.multiply(self.mask, self.G) - tf.multiply(self.mask, self.images))), 1) self.perceptual_loss = self.g_loss_actual self.complete_loss = self.contextual_loss + F.lam * self.perceptual_loss self.grad_complete_loss = tf.gradients(self.complete_loss, self.z_gen) # create summaries for Tensorboard visualization tf.summary.scalar('disc_loss', self.d_loss) tf.summary.scalar('disc_loss_real', self.d_loss_real) tf.summary.scalar('disc_loss_fake', self.d_loss_fake) tf.summary.scalar('gen_loss', self.g_loss_actual) self.g_loss = tf.constant(0) t_vars = tf.trainable_variables() self.d_vars = [var for var in t_vars if 'D/d_' in var.name] self.g_vars = [var for var in t_vars if 'G/g_' in var.name] self.saver = tf.train.Saver()
def main(): if not os.path.exists(args.output_dir): os.makedirs(args.output_dir) # read data from tfrecord files img, label = reader.read_and_decode(args.tfrecords, epochs=args.num_epochs, size=args.img_size) img_batch, label_batch = tf.train.shuffle_batch([img, label], batch_size=args.batch_size, capacity=2000, min_after_dequeue=1000) global_step = tf.Variable(0, name="global_step", trainable=False) # construct network model model = AlexNet(img_batch, args.dropout_rate, args.num_bit, args.num_class, skip_layers) D = model.softsign [d_loss, out] = hashing_loss(D, label_batch, args.alpha, args.belta, args.gama, args.num_bit) # List of trainable variables of the layers to finetune var_list1 = [ v for v in tf.trainable_variables() if v.name.split('/')[0] not in skip_layers ] # List of trainable variables of the layers to train from scratch var_list2 = [ v for v in tf.trainable_variables() if v.name.split('/')[0] in skip_layers ] # learning rate learning_rate = tf.train.exponential_decay(args.lr, global_step, args.decay_step, args.decay_rate, staircase=True) opt1 = tf.train.AdamOptimizer(learning_rate * 0.001) opt2 = tf.train.AdamOptimizer(learning_rate) # apply different grads for two type layers grads = tf.gradients(d_loss, var_list1 + var_list2) grads1 = grads[:len(var_list1)] grads2 = grads[len(var_list1):] train_op1 = opt1.apply_gradients(zip(grads1, var_list1)) train_op2 = opt2.apply_gradients(zip(grads2, var_list2), global_step=global_step) train_op = tf.group(train_op1, train_op2) with tf.Session(config=config) as sess: saver = tf.train.Saver(tf.global_variables()) sess.run([ tf.global_variables_initializer(), tf.local_variables_initializer() ]) if args.checkpoint is not None: checkpoint = tf.train.latest_checkpoint(args.checkpoint) print('Restoring model from {}'.format(checkpoint)) saver.restore(sess, checkpoint) else: # Load the pretrained weights into the non-trainable layer model.load_initial_weights(sess) coord = tf.train.Coordinator() threads = tf.train.start_queue_runners(coord=coord) start_time = time.time() try: while not coord.should_stop(): _, loss_t, dt, step1 = sess.run( [train_op, d_loss, out, global_step]) elapsed_time = time.time() - start_time start_time = time.time() if step1 % 10 == 0: print("iter: %4d, loss: %.8f, time: %.3f" % (step1, loss_t, elapsed_time)) if step1 % args.save_freq == 0: saver.save(sess, args.output_dir + '/model.ckpt', global_step=step1) except tf.errors.OutOfRangeError: saver.save(sess, args.output_dir + '/model-done.ckpt') print('Done training -- epoch limit reached') finally: coord.request_stop() coord.join(threads)
def distorted_inputs(filename, batch_size, num_epochs, num_threads, imshape, imsize, num_examples_per_epoch=128): """Construct distorted input for training using the Reader ops. Raises: ValueError: if no data_dir Args: filename: batch_size: num_epochs: num_threads: imshape: imsize: num_examples_per_epoch: Returns: images: Images. 4D tensor of [batch_size, IMAGE_SIZE, IMAGE_SIZE, 3] size. labels: Labels. 1D tensor of [batch_size] size. """ if not num_epochs: num_epochs = None with tf.name_scope("input"): filename_queue = tf.train.string_input_producer( [filename], num_epochs=num_epochs, name="string_DISTORTED_input_producer" ) # Even when reading in multiple threads, share the filename # queue. image, label = reader.read_and_decode(filename_queue, imshape) # Reshape to [32, 32, 3] as distortion methods need this shape image = tf.reshape(image, imshape) height = imsize width = imsize # Image processing for training the network. Note the many random # distortions applied to the image. # Removed random_crop in new TensorFlow release. # Randomly crop a [height, width] section of the image. # distorted_image = tf.image.random_crop(image, [height, width]) # # Randomly flip the image horizontally. distorted_image = tf.image.random_flip_left_right(image) # # Because these operations are not commutative, consider randomizing # randomize the order their operation. distorted_image = tf.image.random_brightness(distorted_image, max_delta=63) distorted_image = tf.image.random_contrast(distorted_image, lower=0.2, upper=1.8) # # Subtract off the mean and divide by the variance of the pixels. float_image = tf.image.per_image_whitening(distorted_image) num_elements = 1 for i in imshape: num_elements = num_elements * i image = tf.reshape(float_image, [num_elements]) # Ensure that the random shuffling has good mixing properties. min_fraction_of_examples_in_queue = 0.4 min_queue_examples = int(num_examples_per_epoch * min_fraction_of_examples_in_queue) images, sparse_labels = tf.train.shuffle_batch( [image, label], batch_size=batch_size, num_threads=num_threads, capacity=min_queue_examples + 3 * batch_size, enqueue_many=False, # Ensures a minimum amount of shuffling of examples. min_after_dequeue=min_queue_examples, name="batching_shuffling_distortion", ) return images, sparse_labels
def distorted_inputs(filename, batch_size, num_epochs, num_threads, imshape, num_examples_per_epoch=128, flatten=True): """Construct distorted input for training using the Reader ops. Raises: ValueError: if no data_dir Args: filename: The name of the file containing the images batch_size: The number of images per batch num_epochs: The number of epochs passed to string_input_producer num_threads: The number of threads passed to shuffle_batch imshape: Shape of image in [height, width, n_channels] format num_examples_per_epoch: Number of images to use per epoch flatten: Whether to flatten image after image transformations Returns: images: Images. 4D tensor of [batch_size, IMAGE_SIZE, IMAGE_SIZE, 3] size. labels: Labels. 1D tensor of [batch_size] size. """ tf.local_variables_initializer() tf.global_variables_initializer() if not num_epochs: num_epochs = None with tf.name_scope('input'): filename_queue = tf.train.string_input_producer( [filename], num_epochs=num_epochs, name='string_DISTORTED_input_producer') # Even when reading in multiple threads, share the filename # queue. image, label = reader.read_and_decode(filename_queue, imshape) # Reshape to imshape as distortion methods need this shape image = tf.reshape(image, imshape) # Image processing for training the network. Note the many random # distortions applied to the image. # Removed random_crop in new TensorFlow release. # Randomly crop a [height, width] section of the image. # distorted_image = tf.image.random_crop(image, [height, width]) # # Randomly flip the image horizontally. distorted_image = tf.image.random_flip_left_right(image) # # Randomly apply image transformations in random_functions list random_functions = [_random_brightness_helper, _random_contrast_helper] shuffle(random_functions) for fcn in random_functions: distorted_image = fcn(distorted_image) # # Subtract off the mean and divide by the variance of the pixels. float_image = tf.image.per_image_standardization(distorted_image) if flatten: num_elements = 1 for i in imshape: num_elements = num_elements * i image = tf.reshape(float_image, [num_elements]) else: image = float_image # Ensure that the random shuffling has good mixing properties. min_fraction_of_examples_in_queue = 0.4 min_queue_examples = int(num_examples_per_epoch * min_fraction_of_examples_in_queue) images, sparse_labels = tf.train.shuffle_batch([image, label], batch_size=batch_size, num_threads=num_threads, capacity=min_queue_examples + 3 * batch_size, enqueue_many=False, # Ensures a minimum amount of shuffling of examples. min_after_dequeue=min_queue_examples, name='batching_shuffling_distortion') return images, sparse_labels
def build_model(self): # main method for training the conditional GAN if F.use_tfrecords == True: # load images from tfrecords + queue thread runner for better GPU utilization tfrecords_filename = [ 'train_records/' + x for x in os.listdir('train_records/') ] filename_queue = tf.train.string_input_producer(tfrecords_filename, num_epochs=100) self.images_i, self.images_o = reader.read_and_decode( filename_queue, F.batch_size) if F.output_size == 64: self.images_i = tf.image.resize_images(self.images_i, (64, 64)) self.images_o = tf.image.resize_images(self.images_o, (64, 64)) print(self.images_i.shape) print('*********') # augmentation #self.images_i = tf.image.random_brightness(self.images_i, max_delta=0.5) #self.images_i = tf.image.random_contrast(self.images_i, 0.2, 0.5) #self.images_i = tf.image.random_hue(self.images_i, 0.2) # self.images_i = gaussian_noise_layer(self.images_i, 0.2) self.images_i = (self.images_i / 127.5) - 1 self.images_o = (self.images_o / 127.5) - 1 else: self.images_i = tf.placeholder( tf.float32, [F.batch_size, F.output_size, F.output_size, F.c_dim], name='real_images_i') self.images_o = tf.placeholder( tf.float32, [F.batch_size, F.output_size, F.output_size, F.c_dim_o], name='real_images_o') # self.mask = tf.placeholder(tf.float32, [F.batch_size, F.output_size, F.output_size, 3], name='mask') #here the function of mask is to be added so that mask is extracted from image # this mask needs to be the subtitles in images. # self.mask = self.images_i # just for running code I am using mask same as input image. # for img in range(F.batch_size): # mask = get_mask(self.images_i[img]) # self.images_i[img] = tf.multiply(mask, self.images_i[img]) self.is_training = tf.placeholder(tf.bool, name='is_training') # self.get_z_init = tf.placeholder(tf.bool, name='get_z_init') # self.images_m = tf.multiply(self.mask, self.images_i) self.output = self.unet(self.images_i) # self.z_gen = tf.cond(self.get_z_init, lambda: self.generate_z(self.images_), lambda: tf.placeholder(tf.float32, [F.batch_size, 100], name='z_gen')) # self.G = self.generator(self.z_gen) self.loss = 0 if F.vgg_loss == True: data_dict = loadWeightsData('./vgg16.npy') lambda_f = 1 # content target feature vgg_c = custom_Vgg16(self.output, data_dict=data_dict) # feature_i = [vgg_c.conv1_2, vgg_c.conv2_2, vgg_c.conv3_3, vgg_c.conv4_3, vgg_c.conv5_3] feature_i = [vgg_c.conv3_3, vgg_c.conv4_3] # feature after transformation vgg = custom_Vgg16(self.images_o, data_dict=data_dict) # feature_o = [vgg.conv1_2, vgg.conv2_2, vgg.conv3_3, vgg.conv4_3, vgg.conv5_3] feature_o = [vgg.conv3_3, vgg.conv4_3] # compute feature loss # self.loss = tf.zeros(F.batch_size, tf.float32) print(tf.shape(self.loss)) for f, f_ in zip(feature_i, feature_o): # self.loss += lambda_f * tf.reduce_mean(tf.subtract(f, f_) ** 2, [1, 2, 3]) self.loss += lambda_f * tf.reduce_mean(tf.subtract(f_, f)**2) # self.loss += tf.reduce_mean(tf.square(vgg_net['relu3_3'][:F.batch_size] - vgg_net['relu3_3'][F.batch_size:]))# + \ # tf.reduce_mean(tf.square(vgg_net[:F.batch_size] - vgg_net[F.batch_size:])) else: self.loss += ( tf.reduce_sum(tf.square(self.output - self.images_o)) + (0.01 * tf.reduce_sum(tf.image.total_variation(self.output)))) #self.loss = tf.reduce_sum(tf.image.total_variation(self.output)) # self.loss += tf.reduce_sum(tf.square(self.output - self.images_o)) tf.summary.scalar('loss', self.loss) # create summaries for Tensorboard visualization # self.g_loss = tf.constant(0) t_vars = tf.trainable_variables() # print t_vars self.z_vars = [var for var in t_vars if 'U/' in var.name] #print self.z_vars # self.g_vars = [var for var in t_vars if 'G/g_' in var.name] # self.d_vars = [var for var in t_vars if 'G/d_' in var.name] # self.saver_gen = tf.train.Saver(self.g_vars) # + self.d_vars) # try: self.saver = tf.train.Saver()
def build_model(self): if F.use_tfrecords == True: # load images from tfrecords + queue thread runner for better GPU utilization tfrecords_filename = [ 'train_records/' + x for x in os.listdir('train_records/') ] filename_queue = tf.train.string_input_producer(tfrecords_filename, num_epochs=100) self.images_i, self.images_o = reader.read_and_decode( filename_queue, F.batch_size) print('image_loaded') if F.output_size == 64: self.images_i = tf.image.resize_images(self.images_i, (64, 64)) self.images_o = tf.image.resize_images(self.images_o, (64, 64)) print(self.images_i.shape) print('*********') # augmentation #self.images_i = tf.image.random_brightness(self.images_i, max_delta=0.5) #self.images_i = tf.image.random_contrast(self.images_i, 0.2, 0.5) #self.images_i = tf.image.random_hue(self.images_i, 0.2) # self.images_i = gaussian_noise_layer(self.images_i, 0.2) self.images_i = (self.images_i / 127.5) - 1 self.images_o = (self.images_o / 127.5) - 1 else: self.images_o = tf.placeholder( tf.float32, [F.batch_size, F.output_size, F.output_size, F.c_dim], name='real_images') # self.z_gen = tf.placeholder(tf.float32, [None, F.z_dim], name='z') self.is_training = tf.placeholder(tf.bool, name='is_training') self.G_mean = self.generator(self.images_i) self.D, self.D_logits = self.discriminator(self.images_o, self.images_i, reuse=False) self.D_, self.D_logits_, = self.discriminator(self.G_mean, self.images_i, reuse=True) #calculations for getting hard predictions # +1 means fooled the D network while -1 mean D has won self.d_loss_real = tf.reduce_mean( tf.nn.sigmoid_cross_entropy_with_logits(logits=self.D_logits, labels=tf.ones_like( self.D))) self.d_loss_fake = tf.reduce_mean( tf.nn.sigmoid_cross_entropy_with_logits(logits=self.D_logits_, labels=tf.zeros_like( self.D_))) self.d_loss = self.d_loss_real + self.d_loss_fake self.u_loss = tf.reduce_mean(tf.square(self.G_mean - self.images_o)) self.g_loss_actual = tf.reduce_mean( tf.nn.sigmoid_cross_entropy_with_logits(logits=self.D_logits_, labels=tf.ones_like( self.D_))) tf.summary.scalar('loss', self.g_loss_actual) # self.g_loss = tf.constant(0) # print('loss calculated') # if F.error_conceal == True: # self.mask = tf.placeholder(tf.float32, [F.batch_size] + self.image_shape, name='mask') # self.contextual_loss = tf.reduce_sum( # tf.contrib.layers.flatten( # tf.abs(tf.multiply(self.mask, self.G_mean) - tf.multiply(self.mask, self.images_o))), 1) # self.perceptual_loss = self.g_loss_actual # self.complete_loss = self.contextual_loss + F.lam * self.perceptual_loss # self.grad_complete_loss = tf.gradients(self.complete_loss, self.z_gen) t_vars = tf.trainable_variables() self.d_vars = [var for var in t_vars if 'd_' in var.name] self.g_vars = [var for var in t_vars if 'g_' in var.name] self.saver = tf.train.Saver()