def main(_): X_image = tf.placeholder(tf.float32, [None, FLAGS.Out_DIm]) #y_label = tf.placeholder(tf.float32,[None,FLAGS.n_class]) z = tf.random_normal([FLAGS.batch_size, FLAGS.z_dim]) G_image = Generator(z) disc_real = Discriminator(X_image) disc_fake = Discriminator(G_image, True) gen_params = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES, scope="Generator") disc_params = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES, scope="Discriminator") FSR_cost = 0 #********feasible set reduce*************** if FLAGS.is_fsr: reduce_cost = tf.reduce_mean(disc_fake) - tf.reduce_mean(disc_real) FSR_cost = tf.nn.relu(reduce_cost) #****************************************** gen_cost = -tf.reduce_mean(disc_fake) disc_cost = tf.reduce_mean(disc_fake) - tf.reduce_mean(disc_real) global_step = tf.Variable(0) learning_rate = tf.train.exponential_decay(1e-3, global_step, 200, 0.96, staircase=True) clip_ops = [] if FLAGS.is_clip: clip_bound = [-.01, .01] for v in disc_params: clip_ops.append( tf.assign(v, tf.clip_by_value(v, clip_bound[0], clip_bound[1]))) clip_weight_clip = tf.group(*clip_ops) elif FLAGS.is_l2: for v in disc_params: tf.add_to_collection( "loss", tf.multiply(tf.nn.l2_loss(v), FLAGS.l2_regular)) elif FLAGS.is_gp: alpha = tf.random_uniform(shape=[FLAGS.batch_size, 1], minval=0., maxval=1.) differences = G_image - X_image interpolates = X_image + (alpha * differences) gradients = tf.gradients(Discriminator(interpolates, reuse=True), [interpolates])[0] slopes = tf.sqrt( tf.reduce_sum(tf.square(gradients), reduction_indices=[1])) gradient_penalty = tf.reduce_mean((slopes - 1.)**2) gp_cost = 10 * gradient_penalty #tf.add_to_collection("loss",disc_cost) #dis_losses = tf.add_n(tf.get_collection_ref("loss")) dis_losses = disc_cost + gp_cost #dis_losses = disc_cost gen_train = tf.train.AdamOptimizer( learning_rate, beta1=0.5, beta2=0.9).minimize(gen_cost, global_step=global_step, var_list=gen_params) disc_train = tf.train.AdamOptimizer( learning_rate, beta1=0.5, beta2=0.9).minimize(dis_losses, global_step=global_step, var_list=disc_params) #tensor_noise = tf.random_normal([128,128]) tensor_noise = tf.constant( np.random.normal(size=(128, 128)).astype('float32')) gen_save_image = Generator(tensor_noise, reuse=True, nums=128) #mnist_data = input_data.read_data_sets("../data",one_hot=True) with tf.Session() as sess: sess.run(tf.initialize_all_variables()) gen = inf_train_gen() for i in xrange(FLAGS.iter_range): start_time = time.time() #data = mnist_data.train.next_batch(FLAGS.batch_size) data = gen.next() if i > 0: _genc, _ = sess.run([gen_cost, gen_train], feed_dict={X_image: data}) for x in xrange(FLAGS.disc_inter): _disc, _ = sess.run([disc_cost, disc_train], feed_dict={X_image: data}) if i > 0: D_real, D_fake = sess.run([disc_real, disc_fake], feed_dict={X_image: data}) #plot.plot("Generator_cost",_genc) plot.plot("Discriminator", _disc) plot.plot("D_real", np.mean(D_real)) plot.plot("D_fake", np.mean(D_fake)) plot.plot('time', time.time() - start_time) #if clip_ops is not None: # sess.run(clip_weight_clip) if i % 1000 == 999: print "***************************************************" print "D:" print D_real - D_fake print "****************************************************" if i % 100 == 99: print "gp_cost:" print sess.run(gp_cost, feed_dict={X_image: data}) if i % 100 == 99: image = sess.run(gen_save_image) save_images.save_images(image.reshape((128, 28, 28)), "./gen_image_{}.png".format(i)) val_dis_list = [] #for n in xrange(20): #val_data= mnist_data.validation.next_batch(FLAGS.batch_size) #_val_disc = sess.run(disc_cost,feed_dict={X_image:val_data[0],y_label:val_data[1]}) # val_dis_list.append(_val_disc) for images_, _ in dev_data(): _dev_disc_cost = sess.run(disc_cost, feed_dict={X_image: images_}) val_dis_list.append(_dev_disc_cost) plot.plot("val_cost", np.mean(val_dis_list)) if i < 5 or i % 100 == 99: plot.flush() plot.tick()
def main(_): X_image = tf.placeholder(tf.float32, [None, FLAGS.Out_DIm]) y_label_index = tf.placeholder(tf.int32, [None]) y_label = tf.one_hot(y_label_index, FLAGS.n_class) con = tf.random_normal([FLAGS.batch_size, 2]) z = tf.random_normal([FLAGS.batch_size, FLAGS.z_dim]) G_image = Generator(z, con, labels=y_label) disc_real, real_class, _, _class_r = Discriminator(X_image) disc_fake, fake_class, con_fake, _class_f = Discriminator(G_image, True) class_label_real = tf.arg_max(_class_r, 1) class_label_fake = tf.arg_max(_class_f, 1) gen_params = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES, scope="Generator") disc_params = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES, scope="Discriminator") FSR_cost = 0 #********feasible set reduce*************** if FLAGS.is_fsr: reduce_cost = tf.reduce_mean(disc_fake) - tf.reduce_mean(disc_real) FSR_cost = tf.nn.relu(reduce_cost) #****************************************** class_loss_real = tf.reduce_mean( tf.nn.sigmoid_cross_entropy_with_logits(labels=y_label, logits=real_class)) class_loss_fake = tf.reduce_mean( tf.nn.sigmoid_cross_entropy_with_logits(labels=y_label, logits=fake_class)) con_cost = tf.reduce_mean(tf.square(con_fake - con)) gen_cost = -tf.reduce_mean(disc_fake) + 20 * (class_loss_fake + con_cost) disc_cost = tf.reduce_mean(disc_fake) - tf.reduce_mean( disc_real) + 20 * (class_loss_fake + class_loss_real + con_cost) global_step = tf.Variable(0) learning_rate = tf.train.exponential_decay(1e-3, global_step, 200, 0.96, staircase=True) clip_ops = [] if FLAGS.is_clip: clip_bound = [-.01, .01] for v in disc_params: clip_ops.append( tf.assign(v, tf.clip_by_value(v, clip_bound[0], clip_bound[1]))) clip_weight_clip = tf.group(*clip_ops) elif FLAGS.is_l2: for v in disc_params: tf.add_to_collection( "loss", tf.multiply(tf.nn.l2_loss(v), FLAGS.l2_regular)) elif FLAGS.is_gp: alpha = tf.random_uniform(shape=[FLAGS.batch_size, 1], minval=0., maxval=1.) differences = G_image - X_image interpolates = X_image + (alpha * differences) source_logit, class_logit, _, _ = Discriminator(interpolates, reuse=True) gradients = tf.gradients(source_logit, [interpolates])[0] slopes = tf.sqrt( tf.reduce_sum(tf.square(gradients), reduction_indices=[1])) gradient_penalty = tf.reduce_mean((slopes - 1.)**2) disc_cost += 10 * gradient_penalty tf.add_to_collection("loss", disc_cost) dis_losses = tf.add_n(tf.get_collection_ref("loss")) #dis_losses = disc_cost gen_train = tf.train.AdamOptimizer( learning_rate, beta1=0.5, beta2=0.9).minimize(gen_cost, global_step=global_step, var_list=gen_params) disc_train = tf.train.AdamOptimizer( learning_rate, beta1=0.5, beta2=0.9).minimize(dis_losses, global_step=global_step, var_list=disc_params) #tensor_noise = tf.random_normal([128,128]) tensor_noise = tf.constant( np.random.normal(size=(128, 128)).astype('float32')) #tensor_noise = tf.random_normal([128,128]) label = [1 for i in range(128)] label_tensor = tf.one_hot(np.array(label), FLAGS.n_class) con_tensor = tf.constant(np.random.normal(size=(128, 2)).astype('float32')) gen_save_image = Generator(tensor_noise, con=con_tensor, labels=label_tensor, reuse=True, nums=128) _, _, class_gen_label, _ = Discriminator(gen_save_image, reuse=True) gen_label = tf.argmax(class_gen_label, 1) #mnist_data = input_data.read_data_sets("../data",one_hot=True) with tf.Session() as sess: sess.run(tf.global_variables_initializer()) gen = inf_train_gen() for i in xrange(FLAGS.iter_range): start_time = time.time() #data = mnist_data.train.next_batch(FLAGS.batch_size) data_x, data_y = gen.next() if i > 0: _genc, _ = sess.run([gen_cost, gen_train], feed_dict={ X_image: data_x, y_label_index: data_y }) for x in xrange(FLAGS.disc_inter): _disc, _class_real, _class_fake, _ = sess.run( [disc_cost, class_loss_real, class_loss_fake, disc_train], feed_dict={ X_image: data_x, y_label_index: data_y }) if i > 0: #plot.plot("Generator_cost",_genc) plot.plot("Discriminator", _disc) #plot.plot("class_real",_class_real) # plot.plot("class_fake",_class_fake) plot.plot('time', time.time() - start_time) #if clip_ops is not None: # sess.run(clip_weight_clip) if i % 100 == 99: image = sess.run(gen_save_image) save_images.save_images(image.reshape((128, 28, 28)), "./gen_image_{}.png".format(i)) gen_label_ = sess.run(gen_label) val_dis_list = [] #for n in xrange(20): #val_data= mnist_data.validation.next_batch(FLAGS.batch_size) #_val_disc = sess.run(disc_cost,feed_dict={X_image:val_data[0],y_label:val_data[1]}) # val_dis_list.append(_val_disc) print "true_label:" print data_y print "class_real:" print sess.run(class_label_real, feed_dict={ X_image: data_x, y_label_index: data_y }) print "class_fake" print sess.run(class_label_fake, feed_dict={ X_image: data_x, y_label_index: data_y }) print "class_gen:" print gen_label_ print "con_cost:" print sess.run(con_cost, feed_dict={ X_image: data_x, y_label_index: data_y }) print ">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>" for images_, val_label in dev_data(): _dev_disc_cost = sess.run(disc_cost, feed_dict={ X_image: images_, y_label_index: val_label }) val_dis_list.append(_dev_disc_cost) plot.plot("val_cost", np.mean(val_dis_list)) if i < 5 or i % 100 == 99: plot.flush() plot.tick()
def main(_): X_image_int = tf.placeholder(tf.int32, [FLAGS.batch_size, FLAGS.Out_DIm]) X_image = 2 * ((tf.cast(X_image_int, tf.float32) / 255.) - .5) z = tf.random_normal([FLAGS.batch_size, FLAGS.z_dim]) G_image = Generator_k(z) real_image = tf.transpose(tf.reshape(X_image, [-1, 3, 32, 32]), perm=[0, 2, 3, 1]) X_image_i = tf.reshape(real_image, [-1, 3072]) fake_image = tf.reshape(G_image, [-1, 32, 32, 3]) disc_real = Discriminator_k(real_image) disc_fake = Discriminator_k(fake_image, reuse=True) gen_params = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES, scope="Generator") disc_params = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES, scope="Discriminator") gen_cost = -tf.reduce_mean(disc_fake) disc_cost = tf.reduce_mean(disc_fake) - tf.reduce_mean(disc_real) # Gradient penalty alpha = tf.random_uniform(shape=[FLAGS.batch_size, 1], minval=0., maxval=1.) differences = G_image - X_image_i interpolates = X_image_i + (alpha * differences) inter_im = tf.reshape(interpolates, [-1, 32, 32, 3]) gradients = tf.gradients(Discriminator_k(inter_im, reuse=True), [interpolates])[0] slopes = tf.sqrt(tf.reduce_sum(tf.square(gradients), reduction_indices=[1])) gradient_penalty = tf.reduce_mean((slopes - 1.)**2) disc_cost += LAMBDA * gradient_penalty gen_train = tf.train.AdamOptimizer(learning_rate=1e-4, beta1=0.5, beta2=0.9).minimize(gen_cost, var_list=gen_params) disc_train = tf.train.AdamOptimizer(learning_rate=1e-4, beta1=0.5, beta2=0.9).minimize( disc_cost, var_list=disc_params) tensor_noise = tf.constant( np.random.normal(size=(128, 128)).astype('float32')) gen_save_image = Generator_k(z=tensor_noise, reuse=True, nums=128) with tf.Session() as sess: sess.run(tf.initialize_all_variables()) gen = inf_train_gen() for i in xrange(FLAGS.iter_range): start_time = time.time() data = gen.next() if i > 0: _genc, _ = sess.run([gen_cost, gen_train], feed_dict={X_image_int: data}) for x in xrange(FLAGS.disc_inter): _disc, _ = sess.run([disc_cost, disc_train], feed_dict={X_image_int: data}) if i > 0: D_real, D_fake = sess.run([disc_real, disc_fake], feed_dict={X_image_int: data}) #plot.plot("Generator_cost",_genc) plot.plot("Discriminator", _disc) plot.plot("D_real", np.mean(D_real)) plot.plot("D_fake", np.mean(D_fake)) plot.plot('time', time.time() - start_time) #*******************************save image*************************************** if i % 100 == 99: image = sess.run(gen_save_image) images_ = ((image + 1.) * (255. / 2)).astype('int32') lib.save_images.save_images(images_.reshape((128, 32, 32, 3)), 'samples_{}.jpg'.format(i)) val_dis_list = [] for images_, _ in dev_data(): _dev_disc_cost = sess.run(disc_cost, feed_dict={X_image_int: images_}) val_dis_list.append(_dev_disc_cost) plot.plot("val_cost", np.mean(val_dis_list)) if i < 5 or i % 100 == 99: plot.flush() plot.tick()