def define_objective(real_inputs_discrete, y, seq_length):
real_inputs = real_inputs_discrete
train_pred = generator(cf.BATCH_SIZE, y, seq_len=seq_length)
disc_real = discriminator(real_inputs, y, seq_length, reuse=False)
disc_fake = discriminator(train_pred, y, seq_length, reuse=True)
disc_cost, gen_cost = loss_d_g(disc_fake, disc_real, train_pred,
real_inputs, y, seq_length, discriminator)
return disc_cost, gen_cost
def build_GAN(self):
tower_D_grads = []
tower_G_grads = []
with tf.variable_scope(tf.get_variable_scope()):
for i in range(self.num_gpus):
with tf.device('/gpu:%d' % i):
with tf.name_scope('%s_%d' % ("tower", i)) as scope:
# Get this gpu's data
image_batch, label_batch, noise_batch = self.batch_queue.dequeue(
)
# Create the generator graph
self.G_z = generator(noise_batch)
# Create the discriminator graphs
D_real, D_real_logits = discriminator(image_batch)
D_fake, D_fake_logits = discriminator(self.G_z,
reuse=True)
self.compute_loss(self.G_z, D_real, D_real_logits,
D_fake, D_fake_logits, label_batch)
D_vars = [
var for var in tf.trainable_variables()
if var.name.startswith('discriminator')
]
G_vars = [
var for var in tf.trainable_variables()
if var.name.startswith('generator')
]
tf.get_variable_scope().reuse_variables()
D_grads = self.D_optim.compute_gradients(
self.D_loss, var_list=D_vars)
tower_D_grads.append(D_grads)
G_grads = self.G_optim.compute_gradients(
self.G_loss, var_list=G_vars)
tower_G_grads.append(G_grads)
avg_D_grads = self.average_gradients(tower_D_grads)
avg_G_grads = self.average_gradients(tower_G_grads)
update_ops = tf.get_collection(tf.GraphKeys.UPDATE_OPS)
with tf.control_dependencies(update_ops):
self.D_train_op = self.D_optim.apply_gradients(avg_D_grads)
self.G_train_op = self.G_optim.apply_gradients(avg_G_grads)
self.train_op = tf.group(self.D_train_op, self.G_train_op)
def __init__(self, args):
self.args = args
self.device = torch.device('cuda: 0')
self.device_ids = list(map(lambda x: int(x), args.gpus.split(',')))
self.loader1 = get_loader(args.root1, args)
self.loader2 = get_loader(args.root2, args)
self.netG_A = generator(input_nc=3, output_nc=3, n_blocks=9)
self.netG_B = generator(input_nc=3, output_nc=3, n_blocks=9)
self.netD_A = discriminator(input_nc=3)
self.netD_B = discriminator(input_nc=3)
self.netG_A.to(self.device)
self.netG_B.to(self.device)
self.netD_A.to(self.device)
self.netD_B.to(self.device)
self.netG_A = nn.DataParallel(self.netG_A, device_ids=self.device_ids)
self.netG_B = nn.DataParallel(self.netG_B, device_ids=self.device_ids)
self.netD_A = nn.DataParallel(self.netD_A, device_ids=self.device_ids)
self.netD_B = nn.DataParallel(self.netD_B, device_ids=self.device_ids)
init_weights(self.netG_A)
init_weights(self.netG_B)
init_weights(self.netD_A)
init_weights(self.netD_B)
self.fake_A_pool = ImagePool(50)
self.fake_B_pool = ImagePool(50)
self.criterionCycle = nn.L1Loss()
self.criterionGAN = LSGANLoss()
self.start_epoch = 0
self.optimizer_G = torch.optim.Adam(itertools.chain(
self.netG_A.parameters(), self.netG_B.parameters()),
lr=self.args.lr,
betas=(0.5, 0.999))
self.optimizer_D = torch.optim.Adam(itertools.chain(
self.netD_A.parameters(), self.netD_B.parameters()),
lr=self.args.lr,
betas=(0.5, 0.999))
def lambda_rule(epoch):
lr_l = 1.0 - max(0, epoch + 1 - 100) / float(100 + 1)
return lr_l
self.scheduler_G = lr_scheduler.LambdaLR(self.optimizer_G,
lr_lambda=lambda_rule)
self.scheduler_D = lr_scheduler.LambdaLR(self.optimizer_D,
lr_lambda=lambda_rule)
self.create_experiment()
self.get_logger()
def __init__(self):
self.ckpt_path = utils.CKPT_PATH
self.gen = generator()
self.dis = discriminator()
self.gen.summary()
self.dis.summary()
self.gen_optimizer = tf.keras.optimizers.Adam(1e-4)
self.dis_optimizer = tf.keras.optimizers.Adam(1e-4)
self.init_epoch = tf.Variable(0)
self.summary_writer = tf.summary.create_file_writer(utils.SUMMARY_PATH)
self.ckpt = tf.train.Checkpoint(init_epoch=self.init_epoch,
gen=self.gen,
dis=self.dis,
gen_optimizer=self.gen_optimizer,
dis_optimizer=self.dis_optimizer)
self.ckpt_manager = tf.train.CheckpointManager(
self.ckpt, directory=self.ckpt_path, max_to_keep=3)
self.gen_img_path = path.join(utils.OUTPUT_PATH, 'mnist')
if not path.exists(self.gen_img_path):
os.mkdir(self.gen_img_path)
if not path.exists(self.ckpt_path):
os.mkdir(self.ckpt_path)
def main():
train_set = MNIST('./mnist',
train=True,
download=True,
transform=preprocess_img)
train_data = DataLoader(train_set,
batch_size=128,
sampler=ChunkSampler(50000, 0))
val_set = MNIST('./mnist',
train=True,
download=True,
transform=preprocess_img)
val_data = DataLoader(val_set,
batch_size=128,
sampler=ChunkSampler(5000, 50000))
D_net = discriminator()
G_net = generator()
D_optim = get_optimizer(D_net)
G_optim = get_optimizer(G_net)
train_gan(D_DC,
G_DC,
D_DC_optim,
G_DC_optim,
discriminator_loss,
generator_loss,
num_epochs=5)
def train():
(X_train, y_train), (_, _) = mnist.load_data()
# normalize images
X_train = (X_train.astype(np.float32) - 127.5) / 127.5
X_train = X_train.reshape(X_train.shape[0], X_train.shape[1],
X_train.shape[2], 1)
# build GAN
g = generator()
d = discriminator()
opt = Adam(lr=LR, beta_1=B1)
d.trainable = True
d.compile(loss='binary_crossentropy', metrics=['accuracy'], optimizer=opt)
d.trainable = False
dcgan = Sequential([g, d])
opt = Adam(lr=LR, beta_1=B1)
dcgan.compile(loss='binary_crossentropy',
metrics=['accuracy'],
optimizer=opt)
num_batches = int(X_train.shape[0] / BATCH_SIZE)
# create directory
if not os.path.exists(GENERATED_IMAGE_PATH):
os.mkdir(GENERATED_IMAGE_PATH)
if not os.path.exists(GENERATED_MODEL_PATH):
os.mkdir(GENERATED_MODEL_PATH)
print("-------------------")
print("Total epoch:", NUM_EPOCH, "Number of batches:", num_batches)
print("-------------------")
z_pred = np.array([np.random.uniform(-1, 1, 100) for _ in range(49)])
y_g = [1] * BATCH_SIZE
y_d_true = [1] * BATCH_SIZE
y_d_gen = [0] * BATCH_SIZE
for epoch in list(map(lambda x: x + 1, range(NUM_EPOCH))):
for index in range(num_batches):
X_d_true = X_train[index * BATCH_SIZE:(index + 1) * BATCH_SIZE]
X_g = np.array(
[np.random.normal(0, 0.5, 100) for _ in range(BATCH_SIZE)])
X_d_gen = g.predict(X_g, verbose=0)
# train discriminator
d_loss = d.train_on_batch(X_d_true, y_d_true)
d_loss = d.train_on_batch(X_d_gen, y_d_gen)
# train generator
g_loss = dcgan.train_on_batch(X_g, y_g)
show_progress(epoch, index, g_loss[0], d_loss[0], g_loss[1],
d_loss[1])
# save generated images
image = combine_images(g.predict(z_pred))
image = image * 127.5 + 127.5
Image.fromarray(image.astype(np.uint8))\
.save(GENERATED_IMAGE_PATH+"%03depoch.png" % (epoch))
print()
# save models
g.save(GENERATED_MODEL_PATH + 'dcgan_generator.h5')
d.save(GENERATED_MODEL_PATH + 'dcgan_discriminator.h5')
def dis_update(noise, point, generator, discriminator, disopt, genopt):
disopt.zero_grad()
genopt.zero_grad()
output = generator(noise)
fake_output = discriminator(output)
real_output = discriminator(point)
ones = Variable(
torch.FloatTensor(np.ones(real_output.size(0), dtype=np.int)))
zeros = Variable(
torch.FloatTensor(np.zeros(fake_output.size(0), dtype=np.int)))
real_adv_loss = nn.functional.binary_cross_entropy(real_output, ones)
fake_adv_loss = nn.functional.binary_cross_entropy(fake_output, zeros)
adv_loss = real_adv_loss + fake_adv_loss
adv_loss.backward(retain_graph=True)
disopt.step()
def _build_model(self, filename_queue, config):
x_ = self._im_from_tfrecords(filename_queue, config)
# TODO: supervised image generation?
y_ = tf.placeholder(tf.float32, [None, config.y_dim], name="y")
z_ = tf.placeholder(tf.float32, [None, config.z_dim], name="z")
is_training_ = tf.placeholder(tf.bool, name="is_training")
G, G_end_pts = model.generator(z_, is_training_)
D_real, D_real_end_pts = model.discriminator(x_, is_training_)
D_fake, D_fake_end_pts = model.discriminator(G, is_training_, reuse=True)
with tf.variable_scope("Loss_D"):
loss_D_real = tf.losses.sigmoid_cross_entropy(
multi_class_labels=tf.ones_like(D_real), logits=D_real)
loss_D_fake = tf.losses.sigmoid_cross_entropy(
multi_class_labels=tf.zeros_like(D_fake), logits=D_fake)
loss_D = loss_D_real + loss_D_fake
with tf.variable_scope("Loss_G"):
loss_G = tf.losses.sigmoid_cross_entropy(
multi_class_labels=tf.ones_like(D_fake), logits=D_fake)
with tf.variable_scope("Optimizer_D"):
vars_D = [var for var in tf.trainable_variables() \
if "discriminator" in var.name]
opt_D = tf.train.AdamOptimizer(config.lr,
beta1=config.beta1).minimize(loss_D,
self.global_step,
var_list=vars_D)
with tf.variable_scope("Optimizer_G"):
vars_G = [var for var in tf.trainable_variables() \
if "generator" in var.name]
opt_G = tf.train.AdamOptimizer(config.lr,
beta1=config.beta1).minimize(loss_G, var_list=vars_G)
return {"x": x_, "y": y_, "z": z_, "is_training": is_training_,
"G": G, "D_real": D_real, "D_fake": D_fake,
"G_end_pts": G_end_pts,
"D_real_end_pts": D_real_end_pts,
"D_fake_end_pts": D_fake_end_pts,
"loss_D_real": loss_D_real, "loss_D_fake": loss_D_fake,
"loss_D": loss_D, "loss_G": loss_G,
"opt_D": opt_D, "opt_G": opt_G}
def create_model(session, mode):
m = model.discriminator(VOCAB_SIZE, UNIT_SIZE, BATCH_SIZE, MAX_LENGTH,
mode)
ckpt = tf.train.get_checkpoint_state('./saved_model/')
if ckpt:
print("Reading model from %s" % ckpt.model_checkpoint_path)
m.saver.restore(session, ckpt.model_checkpoint_path)
else:
print("Create model with fresh parameters")
session.run(tf.global_variables_initializer())
return m
def train_generator(optimizer, fake_data, loss=nn.BCELoss()):
N = fake_data.size(0)
# Reset gradients
optimizer.zero_grad()
# Sample noise and generate fake data
prediction = discriminator(fake_data)
# Calculate error and backpropagate
error = loss(prediction, ones_target(N))
error.backward()
# Update weights with gradients
optimizer.step()
# Return error
return error
def train_discriminator(optimizer, real_data, fake_data, loss=nn.BCELoss()):
N = real_data.size(0)
# Reset gradients
optimizer.zero_grad()
# 1.1 Train on Real Data
prediction_real = discriminator(real_data)
# Calculate error and backpropagate
error_real = loss(prediction_real, ones_target(N))
error_real.backward()
# 1.2 Train on Fake Data
prediction_fake = discriminator(fake_data)
# Calculate error and backpropagate
error_fake = loss(prediction_fake, zeros_target(N))
error_fake.backward()
# 1.3 Update weights with gradients
optimizer.step()
# Return error and predictions for real and fake inputs
return error_real + error_fake, prediction_real, prediction_fake
def gen_update(noise, generator, discriminator, genopt, disopt):
genopt.zero_grad()
disopt.zero_grad()
output = generator(noise)
real_output = discriminator(output)
ones = Variable(
torch.FloatTensor(np.ones(real_output.size(0), dtype=np.int)))
adv_loss = nn.functional.binary_cross_entropy(real_output, ones)
adv_loss.backward()
genopt.step()
def forward(self, fake, real, discriminator):
fake_detach = fake.detach()
self.loss = 0
for _ in range(self.gan_k):
d_fake = fake.detach()
d_real = real
if self.gan_type.find('WGAN') >= 0:
loss_d = (d_fake - d_real).mean()
if self.gan_type.find('GP') >= 0:
epsilon = Variable(fake_detach.data.new(
fake.size(0), 1, 1, 1).uniform_(),
requires_grad=False)
hat = fake_detach.mul(1 - epsilon) + real.mul(epsilon)
hat.requires_grad = True
d_hat = discriminator(hat)
gradients = torch.autograd.grad(outputs=d_hat.sum(),
inputs=hat,
retain_graph=True,
create_graph=True,
only_inputs=True)[0]
gradients = gradients.view(gradients.size(0), -1)
gradient_norm = gradients.norm(2, dim=1)
gradient_penalty = 10 * gradient_norm.sub(1).pow(2).mean()
loss_d += gradient_penalty
if self.gan_type == 'WGAN':
for p in discriminator.parameters():
p.data.clamp_(-1, 1)
self.loss /= self.gan_k
d_fake_for_g = discriminator(fake)
if self.gan_type.find('WGAN') >= 0:
loss_g = -d_fake_for_g.mean()
return loss_g, loss_d #####
def build_model(self):
# Define a generator and a discriminator
self.G = model.generator(images, self.g_conv_dim, self.c_dim, self.g_repeat_num)
self.D = model.discriminator(images, self.image_size, self.d_conv_dim, self.c_dim, self.d_repeat_num)
# Optimizers
self.g_optimizer = tf.train.AdamOptimizer(self.g_lr, [self.beta1, self.beta2])
self.d_optimizer = tf.train.AdamOptimizer(self.d_lr, [self.beta1, self.beta2])
# Print networks
self.print_network(self.G, 'G')
self.print_network(self.D, 'D')
if tf.test.is_gpu_available(cuda_only=True):
self.G.cuda()
self.D.cuda()
def __init__(self,
n_dim=2,
batch_size=100,
epochs=10,
log_freq=100,
results_path='./results',
make_gif=False):
self.n_dim = n_dim
self.batch_size = batch_size
self.epochs = epochs
self.log_freq = log_freq
self.results_path = results_path
self.results_img_path = results_path + "/imges"
self.make_gif = make_gif
if not os.path.exists(self.results_img_path):
os.makedirs(self.results_img_path)
if self.make_gif and not os.path.exists(self.results_path + "/gif"):
os.makedirs(self.results_path + "/gif")
# data load
self.load_data()
self.dataset_train = tf.data.Dataset.from_tensor_slices(
(self.x_train, self.y_train))
self.dtrain_shuffle = self.dataset_train.shuffle(
self.x_train.shape[0]).batch(self.batch_size)
self.dataset_test = tf.data.Dataset.from_tensor_slices(
(self.x_test, self.y_test))
self.dtest_shuffle = self.dataset_test.shuffle(
self.x_test.shape[0]).batch(1000)
# Models
self.encoder = encoder(n_dim=self.n_dim)
self.decoder = decoder()
self.discriminator = discriminator()
# optimizer
self.ae_opt = tf.keras.optimizers.Adam(0.0001)
self.gen_opt = tf.keras.optimizers.Adam(0.0001, beta_1=0, beta_2=0.9)
self.disc_opt = tf.keras.optimizers.Adam(0.0001, beta_1=0, beta_2=0.9)
self.loss_object = tf.keras.losses.BinaryCrossentropy(from_logits=True)
def loss_d_g(disc_fake, disc_real, fake_inputs, real_inputs, y, seq_length,
discriminator):
disc_cost = tf.reduce_mean(disc_fake) - tf.reduce_mean(disc_real)
gen_cost = -tf.reduce_mean(disc_fake)
# WGAN lipschitz-penalty
alpha = tf.random_uniform(shape=[tf.shape(real_inputs)[0], 1, 1],
minval=0.,
maxval=1.)
differences = fake_inputs - real_inputs
interpolates = real_inputs + (alpha * differences)
gradients = tf.gradients(
discriminator(interpolates, y, seq_length, reuse=True),
[interpolates, y])[0]
slopes = tf.sqrt(
tf.reduce_sum(tf.square(gradients), reduction_indices=[1, 2]))
gradient_penalty = tf.reduce_mean((slopes - 1.)**2)
disc_cost += cf.LAMBDA * gradient_penalty
return disc_cost, gen_cost
def __init__(self, dataset_path, lr, vis_screen, save_path, l1_coef,
l2_coef, batch_size, num_workers, epochs, gpu_id):
self.generator = torch.nn.DataParallel(model.generator().cuda(),
device_ids=self.gpu_id)
self.discriminator = torch.nn.DataParallel(
model.discriminator().cuda(), device_ids=self.gpu_id)
self.discriminator.apply(Utils.weights_init)
self.generator.apply(Utils.weights_init)
self.dataset = Train_Dataset(dataset_path, dataset_name='Market-1501')
self.noise_dim = 100
self.batch_size = batch_size
self.num_workers = num_workers
self.lr = lr
self.beta1 = 0.5
self.num_epochs = epochs
self.l1_coef = l1_coef
self.l2_coef = l2_coef
self.data_loader = DataLoader(self.dataset,
batch_size=self.batch_size,
shuffle=True,
num_workers=self.num_workers)
self.optimD = torch.optim.Adam(self.discriminator.parameters(),
lr=self.lr,
betas=(self.beta1, 0.999))
self.optimG = torch.optim.Adam(self.generator.parameters(),
lr=self.lr,
betas=(self.beta1, 0.999))
#self.logger = Logger(vis_screen)
self.checkpoints_path = 'checkpoints'
self.save_path = save_path
self.gpu_id = gpu_id
def model_setup(self):
'''
build the model
:return: None
'''
self.fake_images_A = np.zeros(
(pool_size, batch_size, img_height, img_width, img_layer))
self.fake_images_B = np.zeros(
(pool_size, batch_size, img_height, img_width, img_layer))
self.input_A = tf.placeholder(
tf.float32, [batch_size, img_height, img_width, img_layer])
self.input_B = tf.placeholder(
tf.float32, [batch_size, img_height, img_width, img_layer])
self.fake_pool_A = tf.placeholder(
tf.float32, [batch_size, img_height, img_width, img_layer])
self.fake_pool_B = tf.placeholder(
tf.float32, [batch_size, img_height, img_width, img_layer])
self.num_fake_inputs = 0
self.lr = tf.placeholder(tf.float32, shape=[], name="lr")
with tf.variable_scope("img2img") as scope:
self.scope = scope
self.fake_B = generator(self.input_A, name="g_A")
self.fake_A = generator(self.input_B, name="g_B")
self.rec_A = discriminator(self.input_A, "d_A")
self.rec_B = discriminator(self.input_B, "d_B")
scope.reuse_variables()
self.fake_rec_A = discriminator(self.fake_A, "d_A")
self.fake_rec_B = discriminator(self.fake_B, "d_B")
self.cyc_A = generator(self.fake_B, "g_B")
self.cyc_B = generator(self.fake_A, "g_A")
scope.reuse_variables()
self.fake_pool_rec_A = discriminator(self.fake_pool_A, "d_A")
self.fake_pool_rec_B = discriminator(self.fake_pool_B, "d_B")
def model_setup(self):
self.input_A = tf.placeholder(
tf.float32, [batch_size, img_width, img_height, img_layer],
name="input_A")
self.input_B = tf.placeholder(
tf.float32, [batch_size, img_width, img_height, img_layer],
name="input_B")
self.fake_pool_A = tf.placeholder(
tf.float32, [None, img_width, img_height, img_layer],
name="fake_pool_A")
self.fake_pool_B = tf.placeholder(
tf.float32, [None, img_width, img_height, img_layer],
name="fake_pool_B")
self.num_fake_inputs = 0
self.lr = tf.placeholder(tf.float32, shape=[], name="lr")
with tf.variable_scope("drugan") as scope:
self.scope = scope
self.fake_B = generator(self.input_A, name="g_A")
self.fake_A = generator(self.input_B, name="g_B")
self.rec_A = discriminator(self.input_A, "d_A")
self.rec_B = discriminator(self.input_B, "d_B")
scope.reuse_variables()
self.fake_rec_A = discriminator(self.fake_A, "d_A")
self.fake_rec_B = discriminator(self.fake_B, "d_B")
self.cyc_A = generator(self.fake_B, "g_B")
self.cyc_B = generator(self.fake_A, "g_A")
scope.reuse_variables()
self.fake_pool_rec_A = discriminator(self.fake_pool_A, "d_A")
self.fake_pool_rec_B = discriminator(self.fake_pool_B, "d_B")
isTraining = tf.placeholder(dtype=tf.bool)
batch_size = 9
learning_rate = 1e-4
epochs = 10
model = 'new_model'
ndims = 128,128
train_images = np.load('./data/train.npy',mmap_mode='r')[:10000]
highres = tf.placeholder(tf.float32, shape=(None, 128, 128, 3))
lowres = tf.placeholder(tf.float32, shape=(None, 64, 64, 3))
#create Networks
g=generator(lowres,ndims,is_training=isTraining)
d_real = discriminator(highres, is_training = isTraining)
d_fake = discriminator(g, is_training = isTraining ,reuse = True)
#compute Loss
d_loss_real = tf.reduce_mean(tf.nn.sigmoid_cross_entropy_with_logits(logits=d_real, labels=tf.ones_like(d_real)))
d_loss_fake = tf.reduce_mean(tf.nn.sigmoid_cross_entropy_with_logits(logits=d_fake, labels=tf.zeros_like(d_fake)))
d_loss = d_loss_real + d_loss_fake
g_loss = tf.reduce_mean(tf.nn.sigmoid_cross_entropy_with_logits(logits=d_fake, labels=tf.ones_like(d_fake))) * 0.1 + tf.reduce_mean(tf.abs(tf.subtract(g, highres)))
#Variables
d_training_vars = [v for v in tf.trainable_variables() if v.name.startswith('discriminator')]
g_training_vars = [v for v in tf.trainable_variables() if v.name.startswith('generator')]
#optimizer
update_ops = tf.get_collection(tf.GraphKeys.UPDATE_OPS)
with tf.control_dependencies(update_ops):
def run_uda_training(log_dir, images_sd_tr, labels_sd_tr, images_sd_vl,
labels_sd_vl, images_td_tr, images_td_vl):
# ================================================================
# reset the graph built so far and build a new TF graph
# ================================================================
tf.reset_default_graph()
with tf.Graph().as_default():
# ============================
# set random seed for reproducibility
# ============================
tf.random.set_random_seed(exp_config.run_num_uda)
np.random.seed(exp_config.run_num_uda)
# ================================================================
# create placeholders - segmentation net
# ================================================================
images_sd_pl = tf.placeholder(tf.float32,
shape=[exp_config.batch_size] +
list(exp_config.image_size) + [1],
name='images_sd')
images_td_pl = tf.placeholder(tf.float32,
shape=[exp_config.batch_size] +
list(exp_config.image_size) + [1],
name='images_td')
labels_sd_pl = tf.placeholder(tf.uint8,
shape=[exp_config.batch_size] +
list(exp_config.image_size),
name='labels_sd')
training_pl = tf.placeholder(tf.bool,
shape=[],
name='training_or_testing')
# ================================================================
# insert a normalization module in front of the segmentation network
# ================================================================
images_sd_normalized, _ = model.normalize(images_sd_pl,
exp_config,
training_pl,
scope_reuse=False)
images_td_normalized, _ = model.normalize(images_td_pl,
exp_config,
training_pl,
scope_reuse=True)
# ================================================================
# get logit predictions from the segmentation network
# ================================================================
predicted_seg_sd_logits, _, _ = model.predict_i2l(images_sd_normalized,
exp_config,
training_pl,
scope_reuse=False)
# ================================================================
# get all features from the segmentation network
# ================================================================
seg_features_sd = model.get_all_features(images_sd_normalized,
exp_config,
scope_reuse=True)
seg_features_td = model.get_all_features(images_td_normalized,
exp_config,
scope_reuse=True)
# ================================================================
# resize all features to the same size
# ================================================================
images_sd_features_resized = model.resize_features(
[images_sd_normalized] + list(seg_features_sd), (64, 64),
'resize_sd_xfeat')
images_td_features_resized = model.resize_features(
[images_td_normalized] + list(seg_features_td), (64, 64),
'resize_td_xfeat')
# ================================================================
# discriminator on features
# ================================================================
d_logits_sd = model.discriminator(images_sd_features_resized,
exp_config,
training_pl,
scope_name='discriminator',
scope_reuse=False)
d_logits_td = model.discriminator(images_td_features_resized,
exp_config,
training_pl,
scope_name='discriminator',
scope_reuse=True)
# ================================================================
# add ops for calculation of the discriminator loss
# ================================================================
d_loss_sd = tf.nn.sigmoid_cross_entropy_with_logits(
labels=tf.ones_like(d_logits_sd), logits=d_logits_sd)
d_loss_td = tf.nn.sigmoid_cross_entropy_with_logits(
labels=tf.zeros_like(d_logits_td), logits=d_logits_td)
loss_d_op = tf.reduce_mean(d_loss_sd + d_loss_td)
tf.summary.scalar('tr_losses/loss_discriminator', loss_d_op)
# ================================================================
# add ops for calculation of the adversarial loss that tries to get domain invariant features in the normalized image space
# ================================================================
loss_g_op = model.loss_invariance(d_logits_td)
tf.summary.scalar('tr_losses/loss_invariant_features', loss_g_op)
# ================================================================
# add ops for calculation of the supervised segmentation loss
# ================================================================
loss_seg_op = model.loss(predicted_seg_sd_logits,
labels_sd_pl,
nlabels=exp_config.nlabels,
loss_type=exp_config.loss_type_i2l)
tf.summary.scalar('tr_losses/loss_segmentation', loss_seg_op)
# ================================================================
# total training loss for uda
# ================================================================
loss_total_op = loss_seg_op + exp_config.lambda_uda * loss_g_op
tf.summary.scalar('tr_losses/loss_total_uda', loss_total_op)
# ================================================================
# merge all summaries
# ================================================================
summary_scalars = tf.summary.merge_all()
# ================================================================
# divide the vars into segmentation network, normalization network and the discriminator network
# ================================================================
i2l_vars = []
normalization_vars = []
discriminator_vars = []
for v in tf.global_variables():
var_name = v.name
if 'image_normalizer' in var_name:
normalization_vars.append(v)
i2l_vars.append(
v
) # the normalization vars also need to be restored from the pre-trained i2l mapper
elif 'i2l_mapper' in var_name:
i2l_vars.append(v)
elif 'discriminator' in var_name:
discriminator_vars.append(v)
# ================================================================
# add optimization ops
# ================================================================
train_i2l_op = model.training_step(
loss_total_op,
i2l_vars,
exp_config.optimizer_handle,
learning_rate=exp_config.learning_rate)
train_discriminator_op = model.training_step(
loss_d_op,
discriminator_vars,
exp_config.optimizer_handle,
learning_rate=exp_config.learning_rate)
# ================================================================
# add ops for model evaluation
# ================================================================
eval_loss = model.evaluation_i2l_uda_invariant_features(
predicted_seg_sd_logits,
labels_sd_pl,
images_sd_pl,
d_logits_td,
nlabels=exp_config.nlabels,
loss_type=exp_config.loss_type_i2l)
# ================================================================
# add ops for adding image summary to tensorboard
# ================================================================
summary_images = model.write_image_summary_uda_invariant_features(
predicted_seg_sd_logits, labels_sd_pl, images_sd_pl,
exp_config.nlabels)
# ================================================================
# build the summary Tensor based on the TF collection of Summaries.
# ================================================================
if exp_config.debug: print('creating summary op...')
# ================================================================
# add init ops
# ================================================================
init_ops = tf.global_variables_initializer()
# ================================================================
# find if any vars are uninitialized
# ================================================================
if exp_config.debug:
logging.info(
'Adding the op to get a list of initialized variables...')
uninit_vars = tf.report_uninitialized_variables()
# ================================================================
# create session
# ================================================================
sess = tf.Session()
# ================================================================
# create a file writer object
# This writes Summary protocol buffers to event files.
# https://github.com/tensorflow/docs/blob/r1.12/site/en/api_docs/python/tf/summary/FileWriter.md
# The FileWriter class provides a mechanism to create an event file in a given directory and add summaries and events to it.
# The class updates the file contents asynchronously.
# This allows a training program to call methods to add data to the file directly from the training loop, without slowing down training.
# ================================================================
summary_writer = tf.summary.FileWriter(log_dir, sess.graph)
# ================================================================
# create savers
# ================================================================
saver = tf.train.Saver(var_list=i2l_vars)
saver_lowest_loss = tf.train.Saver(var_list=i2l_vars, max_to_keep=3)
# ================================================================
# summaries of the validation errors
# ================================================================
vl_error_seg = tf.placeholder(tf.float32,
shape=[],
name='vl_error_seg')
vl_error_seg_summary = tf.summary.scalar('validation/loss_seg',
vl_error_seg)
vl_dice = tf.placeholder(tf.float32, shape=[], name='vl_dice')
vl_dice_summary = tf.summary.scalar('validation/dice', vl_dice)
vl_error_invariance = tf.placeholder(tf.float32,
shape=[],
name='vl_error_invariance')
vl_error_invariance_summary = tf.summary.scalar(
'validation/loss_invariance', vl_error_invariance)
vl_error_total = tf.placeholder(tf.float32,
shape=[],
name='vl_error_total')
vl_error_total_summary = tf.summary.scalar('validation/loss_total',
vl_error_total)
vl_summary = tf.summary.merge([
vl_error_seg_summary, vl_dice_summary, vl_error_invariance_summary,
vl_error_total_summary
])
# ================================================================
# summaries of the training errors
# ================================================================
tr_error_seg = tf.placeholder(tf.float32,
shape=[],
name='tr_error_seg')
tr_error_seg_summary = tf.summary.scalar('training/loss_seg',
tr_error_seg)
tr_dice = tf.placeholder(tf.float32, shape=[], name='tr_dice')
tr_dice_summary = tf.summary.scalar('training/dice', tr_dice)
tr_error_invariance = tf.placeholder(tf.float32,
shape=[],
name='tr_error_invariance')
tr_error_invariance_summary = tf.summary.scalar(
'training/loss_invariance', tr_error_invariance)
tr_error_total = tf.placeholder(tf.float32,
shape=[],
name='tr_error_total')
tr_error_total_summary = tf.summary.scalar('training/loss_total',
tr_error_total)
tr_summary = tf.summary.merge([
tr_error_seg_summary, tr_dice_summary, tr_error_invariance_summary,
tr_error_total_summary
])
# ================================================================
# freeze the graph before execution
# ================================================================
if exp_config.debug:
logging.info(
'============================================================')
logging.info('Freezing the graph now!')
tf.get_default_graph().finalize()
# ================================================================
# Run the Op to initialize the variables.
# ================================================================
if exp_config.debug:
logging.info(
'============================================================')
logging.info('initializing all variables...')
sess.run(init_ops)
# ================================================================
# print names of uninitialized variables
# ================================================================
uninit_variables = sess.run(uninit_vars)
if exp_config.debug:
logging.info(
'============================================================')
logging.info('This is the list of uninitialized variables:')
for v in uninit_variables:
print(v)
# ================================================================
# Restore the segmentation network parameters and the pre-trained i2i mapper parameters
# ================================================================
if exp_config.train_from_scratch is False:
logging.info(
'============================================================')
path_to_model = sys_config.log_root + exp_config.expname_i2l + '/models/'
checkpoint_path = utils.get_latest_model_checkpoint_path(
path_to_model, 'best_dice.ckpt')
logging.info('Restoring the trained parameters from %s...' %
checkpoint_path)
saver_lowest_loss.restore(sess, checkpoint_path)
# ================================================================
# run training steps
# ================================================================
step = 0
lowest_loss = 10000.0
validation_total_loss_list = []
while (step < exp_config.max_steps):
# ================================================
# batches
# ================================================
for batch in iterate_minibatches(images_sd=images_sd_tr,
labels_sd=labels_sd_tr,
images_td=images_td_tr,
batch_size=exp_config.batch_size):
x_sd, y_sd, x_td = batch
# ===========================
# define feed dict for this iteration
# ===========================
feed_dict = {
images_sd_pl: x_sd,
labels_sd_pl: y_sd,
images_td_pl: x_td,
training_pl: True
}
# ================================================
# update i2l and D successively
# ================================================
sess.run(train_i2l_op, feed_dict=feed_dict)
sess.run(train_discriminator_op, feed_dict=feed_dict)
# ===========================
# write the summaries and print an overview fairly often
# ===========================
if (step + 1) % exp_config.summary_writing_frequency == 0:
logging.info(
'============== Updating summary at step %d ' % step)
summary_writer.add_summary(
sess.run(summary_scalars, feed_dict=feed_dict), step)
summary_writer.flush()
# ===========================
# Compute the loss on the entire training set
# ===========================
if step % exp_config.train_eval_frequency == 0:
logging.info('============== Training Data Eval:')
train_loss_seg, train_dice, train_loss_invariance = do_eval(
sess, eval_loss, images_sd_pl, labels_sd_pl,
images_td_pl, training_pl, images_sd_tr, labels_sd_tr,
images_td_tr, exp_config.batch_size)
# total training loss
train_total_loss = train_loss_seg + exp_config.lambda_uda * train_loss_invariance
# ===========================
# update tensorboard summary of scalars
# ===========================
tr_summary_msg = sess.run(tr_summary,
feed_dict={
tr_error_seg: train_loss_seg,
tr_dice: train_dice,
tr_error_invariance:
train_loss_invariance,
tr_error_total:
train_total_loss
})
summary_writer.add_summary(tr_summary_msg, step)
# ===========================
# Save a checkpoint periodically
# ===========================
if step % exp_config.save_frequency == 0:
logging.info(
'============== Periodically saving checkpoint:')
checkpoint_file = os.path.join(log_dir,
'models/model.ckpt')
saver.save(sess, checkpoint_file, global_step=step)
# ===========================
# Evaluate the model periodically on a validation set
# ===========================
if step % exp_config.val_eval_frequency == 0:
logging.info('============== Validation Data Eval:')
val_loss_seg, val_dice, val_loss_invariance = do_eval(
sess, eval_loss, images_sd_pl, labels_sd_pl,
images_td_pl, training_pl, images_sd_vl, labels_sd_vl,
images_td_vl, exp_config.batch_size)
# total val loss
val_total_loss = val_loss_seg + exp_config.lambda_uda * val_loss_invariance
validation_total_loss_list.append(val_total_loss)
# ===========================
# update tensorboard summary of scalars
# ===========================
vl_summary_msg = sess.run(vl_summary,
feed_dict={
vl_error_seg: val_loss_seg,
vl_dice: val_dice,
vl_error_invariance:
val_loss_invariance,
vl_error_total:
val_total_loss
})
summary_writer.add_summary(vl_summary_msg, step)
# ===========================
# update tensorboard summary of images
# ===========================
summary_writer.add_summary(
sess.run(summary_images,
feed_dict={
images_sd_pl: x_sd,
labels_sd_pl: y_sd,
training_pl: False
}), step)
summary_writer.flush()
# ===========================
# save model if the val dice is the best yet
# ===========================
window_length = 5
if len(validation_total_loss_list) < window_length + 1:
expo_moving_avg_loss_value = validation_total_loss_list[
-1]
else:
expo_moving_avg_loss_value = utils.exponential_moving_average(
validation_total_loss_list,
window=window_length)[-1]
if expo_moving_avg_loss_value < lowest_loss:
lowest_loss = val_total_loss
lowest_loss_file = os.path.join(
log_dir, 'models/lowest_loss.ckpt')
saver_lowest_loss.save(sess,
lowest_loss_file,
global_step=step)
logging.info(
'******* SAVED MODEL at NEW BEST AVERAGE LOSS on VALIDATION SET at step %d ********'
% step)
# ================================================
# increment step
# ================================================
step += 1
# ================================================================
# close tf session
# ================================================================
sess.close()
return 0
def main(trainSet,userCount,itemCount,testSet,GroundTruth,trainVector,testMaskVector,batchCount,epochCount,pro_zp):
X=[] #画图数据的保存
precisionList=[]
G=model.generator(itemCount)
D=model.discriminator(itemCount)
G = G.cuda()
D = D.cuda()
criterion1 = nn.BCELoss() # 二分类的交叉熵
criterion2 = nn.MSELoss()
d_optimizer = torch.optim.Adam(D.parameters(), lr=0.0001)
g_optimizer = torch.optim.Adam(G.parameters(), lr=0.0001)
G_step=2
D_step=2
batchSize_G = 32
batchSize_D = 32
realLabel_G = Variable(torch.ones(batchSize_G)).cuda()
fakeLabel_G = Variable(torch.zeros(batchSize_G)).cuda()
realLabel_D = Variable(torch.ones(batchSize_D)).cuda()
fakeLabel_D = Variable(torch.zeros(batchSize_D)).cuda()
ZR = []
PM = []
for epoch in range(epochCount): #训练epochCount次
if(epoch%100==0):
ZR = []
PM = []
for i in range(userCount):
ZR.append([])
PM.append([])
ZR[i].append(np.random.choice(itemCount,pro_zp,replace=False))
PM[i].append(np.random.choice(itemCount,pro_zp,replace=False))
for step in range(D_step):#训练D
#maskVector1是PM方法的体现 这里要进行优化 减少程序消耗的内存
leftIndex=random.randint(1,userCount-batchSize_D-1)
realData=Variable(trainVector[leftIndex:leftIndex+batchSize_D]).cuda() #MD个数据成为待训练数据
maskVector1 = Variable(trainVector[leftIndex:leftIndex+batchSize_D]).cuda()
for i in range(len(maskVector1)):
maskVector1[i][PM[leftIndex+i]]=1
Condition=realData#把用户反馈数据作为他的特征 后期还要加入用户年龄、性别等信息
realData_result=D(realData,Condition)
d_loss_real=criterion1(realData_result,realLabel_D)
fakeData=G(realData)
fakeData=fakeData*maskVector1
fakeData_result=D(fakeData,realData)
d_loss_fake=criterion1(fakeData_result,fakeLabel_D)
d_loss=d_loss_real+d_loss_fake
d_optimizer.zero_grad()
d_loss.backward()
d_optimizer.step()
for step in range(G_step):#训练G0
#调整maskVector2\3
leftIndex = random.randint(1, userCount - batchSize_G - 1)
realData = Variable(trainVector[leftIndex:leftIndex + batchSize_G]).cuda()
maskVector2 = Variable(trainVector[leftIndex:leftIndex + batchSize_G]).cuda()
maskVector3 = Variable(trainVector[leftIndex:leftIndex + batchSize_G]).cuda()
for i in range(len(maskVector2)):
maskVector2[i][PM[i+leftIndex]] = 1
maskVector3[i][ZR[i+leftIndex]] = 1
fakeData=G(realData)
fakeData=fakeData*maskVector2
g_fakeData_result=D(fakeData,realData)
g_loss=criterion1(g_fakeData_result,realLabel_G)+0.03*criterion2(fakeData,maskVector3)
g_optimizer.zero_grad()
g_loss.backward()
g_optimizer.step()
if( epoch%10==0):
hit=0
peopleAmount=len(GroundTruth)
recommendAmount=10
index=0
for testUser in testSet.keys():
data = Variable(trainVector[testUser]).cuda()
result = G(data) + Variable(testMaskVector[index]).cuda()
index+=1
hit = hit + evaluation.computeTopNAccuracy(testSet[testUser], result, recommendAmount)
precision=hit/(peopleAmount*recommendAmount)
precisionList.append(precision)
X.append(epoch)
print('Epoch[{}/{}],d_loss:{:.6f},g_loss:{:.6f},precision:{}'.format(epoch, epochCount,
d_loss.item(),
g_loss.item(),
hit/(peopleAmount*recommendAmount)))
paint(X,precisionList)
return precisionList
(te_data, te_label)).batch(opt.BATCH_SIZE)
"""
Model.
"""
'''create classifier'''
classifier = classifier()
optim = keras.optimizers.Adam(lr=opt.LR, decay=opt.DECAY)
classifier.build(input_shape=(opt.BATCH_SIZE, opt.WINDOW_SIZE, opt.WINDOW_SIZE,
opt.CHANNEL, 1))
classifier.summary()
'''create feature generator & feature discriminator'''
fea_g = generator()
fea_g.build(input_shape=(opt.BATCH_SIZE, opt.DIM_Z))
fea_g.summary()
fea_d = discriminator()
fea_d.build(input_shape=(opt.BATCH_SIZE, 17 * 17 * 64))
fea_d.summary()
d_loss, g_loss = dcgan_loss()
fea_g_optim = keras.optimizers.Adam(learning_rate=opt.GAN_LR, beta_1=0.5)
fea_d_optim = keras.optimizers.Adam(learning_rate=opt.GAN_LR, beta_1=0.5)
"""
Test Function.
"""
def test_func(te_data, te_label):
print("Start testing using test data!")
_, te_pred = classifier.predict(te_data)
te_label = tf.argmax(te_label, axis=1)
def train():
###==========LOAD DATA==========###
train_img_list = sorted(
tl.files.load_file_list(path=DATAPATH, regx='.*.jpg', printable=False))
train_imgs = tl.vis.read_images(train_img_list,
path=DATAPATH,
n_threads=16)
###==========MODEL DEFINIATION==========###
z_input = tf.placeholder('float32', [batch_size, z_dim],
name='Input_noise')
image_groundTruth = tf.placeholder(
'float32', [batch_size, input_crop_size, input_crop_size, 3],
name='GroundTruth_Image')
net_g = generator(z_input, input_crop_size, is_train=True, reuse=False)
net_d, logits_real = discriminator(image_groundTruth,
is_train=True,
reuse=False)
_, logits_fake = discriminator(net_g.outputs, is_train=True, reuse=True)
# Normal GAN
# d_loss1 = tl.cost.sigmoid_cross_entropy(logits_real, tf.ones_like(logits_real), name='d1')
# d_loss2 = tl.cost.sigmoid_cross_entropy(logits_fake, tf.zeros_like(logits_fake), name='d2')
# d_loss = d_loss1 + d_loss2
# Wasserstein GAN
d_loss_real = -tf.reduce_mean(logits_real)
d_loss_fake = tf.reduce_mean(logits_fake)
d_loss = d_loss_real + d_loss_fake
em_estimate = -d_loss
# g_loss = tl.cost.sigmoid_cross_entropy(logits_fake, tf.ones_like(logits_fake), name='g')
g_loss = -d_loss_fake
""" Gradient Penalty """
# This is borrowed from https://github.com/kodalinaveen3/DRAGAN/blob/master/DRAGAN.ipynb
alpha = tf.random_uniform(shape=[batch_size, 1, 1, 1],
minval=0.,
maxval=1.)
differences = net_g.outputs - image_groundTruth # This is different from MAGAN
interpolates = image_groundTruth + (alpha * differences)
# _, logits_inter = discriminator_deep(interpolates, is_train = True, reuse = True)
_, logits_inter = discriminator(interpolates, is_train=True, reuse=True)
gradients = tf.gradients(logits_inter, [interpolates])[0]
slopes = tf.sqrt(
tf.reduce_sum(tf.square(gradients), reduction_indices=[1, 2, 3]))
gradient_penalty = tf.reduce_mean((slopes - 1.)**2)
d_loss += GP_lambd * gradient_penalty
g_vars = tl.layers.get_variables_with_name('Generator', True, True)
d_vars = tl.layers.get_variables_with_name('Discriminator', True, True)
with tf.variable_scope('learning_rate'):
lr_v = tf.Variable(lr_init, trainable=False)
g_optim = tf.train.AdamOptimizer(lr_v, beta1=beta1,
beta2=beta2).minimize(g_loss,
var_list=g_vars)
d_optim = tf.train.AdamOptimizer(lr_v, beta1=beta1,
beta2=beta2).minimize(d_loss,
var_list=d_vars)
net_g_test = generator(z_input,
input_crop_size,
is_train=False,
reuse=True)
###========== ==========###
sess = tf.Session()
tl.layers.initialize_global_variables(sess)
sess.run(tf.assign(lr_v, lr_init))
###========== Initialize ==========###
###========== Training ==========###
iter = 0
step_time = 0
for epoch in range(0, nb_epochs):
epoch_time = time.time()
total_d_loss, total_g_loss, n_iter = 0, 0, 0
errD, EMDist = 0, 0
errG = 0
for idx in range(0, len(train_imgs), batch_size):
#Throw the batch away!
if (len(train_imgs) - idx < batch_size):
break
iter += 1
errD, EMDist, errG = 0, 0, 0
step_time = time.time()
batch_z = np.random.uniform(-1, 1,
[batch_size, z_dim]).astype(np.float32)
batch_imgs = tl.prepro.threading_data(train_imgs[idx:idx +
batch_size],
fn=crop_sub_imgs_fn)
# batch_imgs = tl.prepro.threading_data(train_imgs[idx:idx + batch_size], fn=check_imgs_resize)
if (iter == 1):
tl.vis.save_images(
batch_imgs, [8, int(math.ceil(float(batch_size) / 8.0))],
OUTPATH + '/Input_Sample.png')
'''update D'''
_errD, _EMDist, _ = sess.run([d_loss, em_estimate, d_optim], {
z_input: batch_z,
image_groundTruth: batch_imgs
})
# errD = errD + _errD / float(d_iters)
# EMDist = EMDist + _EMDist / float(d_iters)
errD += _errD
EMDist += _EMDist
print("D", end='')
sys.stdout.flush()
if (iter % d_iters == 0):
'''update G'''
_errG, _ = sess.run([g_loss, g_optim], {
z_input: batch_z,
image_groundTruth: batch_imgs
})
# errG = errG + _errG / float(g_iters)
errG += _errG
print("G", end='')
sys.stdout.flush()
print(
"\tEpoch [%2d/%2d] %4d time: %4.4fs, d_loss: %.8f g_loss: %.8f em_estimate: %.8f"
% (epoch, nb_epochs, n_iter, time.time() - step_time, errD,
errG, EMDist))
n_iter += 1
log = "\n[*] Epoch: [%2d/%2d] time: %4.4fs, d_loss: %.8f g_loss: %.8f\n" % (
epoch, nb_epochs, time.time() - epoch_time, total_d_loss / n_iter,
total_g_loss / n_iter)
print(log)
## generate sample images
if (epoch != 0) and (epoch % epochs_saveImg == 0):
batch_z = np.random.uniform(-1, 1,
[batch_size, z_dim]).astype(np.float32)
out = sess.run(net_g_test.outputs, {z_input: batch_z})
print(">>> Saving images...")
tl.vis.save_images(out,
[8, int(math.ceil(float(batch_size) / 8.0))],
OUTPATH + '/train_%d.png' % epoch)
def train(noise_dim, gen_lr, disc_lr, batch_size, num_epochs, save_every,
tensorboard_vis):
"""Trains the Deep Convolutional Generative Adversarial Network (DCGAN).
See https://arxiv.org/abs/1511.06434 for more details.
Args: optional arguments [python train.py --help]
"""
# Load Dataset.
logging.info('loading LFW dataset into memory')
X, IMAGE_SHAPE = load_dataset(dimx=36, dimy=36)
tf.reset_default_graph()
try:
if not tf.test.is_gpu_available(cuda_only=True):
raise Exception
except Exception:
logging.critical('CUDA capable GPU device not found.')
exit(0)
logging.warn('constructing graph on GPU')
with tf.device('/gpu:0'):
# Define placeholders for input data.
noise = tf.placeholder('float32', [None, noise_dim])
real_data = tf.placeholder('float32', [
None,
] + list(IMAGE_SHAPE))
# Create Generator and Discriminator models.
logging.debug('creating generator and discriminator')
g_out = generator(noise, train=True)
d_probs, d_fake_logits = discriminator(g_out, train=True)
d_probs2, d_real_logits = discriminator(real_data, train=True)
logging.debug('defining training ops')
# Define Generator(G) ops.
g_loss = tf.reduce_mean(
tf.nn.sigmoid_cross_entropy_with_logits(
logits=d_fake_logits, labels=tf.ones_like(d_fake_logits)))
g_optimizer = tf.train.AdamOptimizer(learning_rate=gen_lr)
g_vars = get_vars_by_scope('generator')
g_train_step = g_optimizer.minimize(g_loss, var_list=g_vars)
# Define Discriminator(D) ops.
d_loss_real = tf.reduce_mean(
tf.nn.sigmoid_cross_entropy_with_logits(
logits=d_real_logits, labels=tf.ones_like(d_real_logits)))
d_loss_fake = tf.reduce_mean(
tf.nn.sigmoid_cross_entropy_with_logits(
logits=d_fake_logits, labels=tf.zeros_like(d_real_logits)))
d_loss = d_loss_real + d_loss_fake
d_optimizer = tf.train.AdamOptimizer(learning_rate=disc_lr)
d_vars = get_vars_by_scope('discriminator')
d_train_step = d_optimizer.minimize(d_loss, var_list=d_vars)
with tf.Session() as sess:
# Init vars.
sess.run(tf.global_variables_initializer())
# Start training.
logging.debug('training DCGAN model')
for epoch in range(num_epochs):
eval_noise = sample_noise_batch(16)
idx = np.random.choice(range(X.shape[0]), size=16)
eval_real_data = X[idx]
for X_batch in tqdm(iterate_minibatches(X,
batch_size,
shuffle=True),
total=X.shape[0] // batch_size,
desc='Epoch[{}/{}]'.format(
epoch + 1, num_epochs),
leave=False):
sess.run([d_train_step],
feed_dict={
real_data: X_batch,
noise: sample_noise_batch(batch_size)
})
for _ in range(2):
sess.run([g_train_step],
feed_dict={noise: sample_noise_batch(batch_size)})
# Evaluating model after every epoch.
d_loss_iter, g_loss_iter, eval_images = sess.run(
[d_loss, g_loss, g_out],
feed_dict={
real_data: eval_real_data,
noise: eval_noise
})
# Generate images using G and save in `out/`.
tl.visualize.save_images(eval_images, [4, 4],
'out/eval_{}.png'.format(epoch + 1))
logging.info(
'Epoch[{}/{}] g_loss: {:.6f} - d_loss: {:.6f}'.format(
epoch + 1, num_epochs, g_loss_iter, d_loss_iter))
def main(_):
assert np.sqrt(
FLAGS.sample_size
) % 1 == 0., 'Flag `sample_size` needs to be a perfect square'
num_tiles = int(np.sqrt(FLAGS.sample_size))
# Print flags
for flag, _ in FLAGS.__flags.items():
print('"{}": {}'.format(flag, getattr(FLAGS, flag)))
print("--------------------")
# Configure checkpoint/samples dir
tl.files.exists_or_mkdir(FLAGS.checkpoint_dir)
tl.files.exists_or_mkdir(FLAGS.sample_dir)
z_dim = 100 # noise dim
# Construct graph on GPU
with tf.device("/gpu:0"):
""" Define Models """
z = tf.placeholder(tf.float32, [None, z_dim], name='z_noise')
real_images = tf.placeholder(
tf.float32,
[None, FLAGS.output_size, FLAGS.output_size, FLAGS.c_dim],
name='real_images')
# Input noise into generator for training
net_g = generator(z, is_train=True, reuse=False)
# Input real and generated fake images into discriminator for training
net_d, d_logits = discriminator(net_g.outputs,
is_train=True,
reuse=False)
_, d2_logits = discriminator(real_images, is_train=True, reuse=True)
# Input noise into generator for evaluation
# set is_train to False so that BatchNormLayer behave differently
net_g2 = generator(z, is_train=False, reuse=True)
""" Define Training Operations """
# discriminator: real images are labelled as 1
d_loss_real = tl.cost.sigmoid_cross_entropy(d2_logits,
tf.ones_like(d2_logits),
name='dreal')
# discriminator: images from generator (fake) are labelled as 0
d_loss_fake = tl.cost.sigmoid_cross_entropy(d_logits,
tf.zeros_like(d_logits),
name='dfake')
# cost for updating discriminator
d_loss = d_loss_real + d_loss_fake
# generator: try to make the the fake images look real (1)
g_loss = tl.cost.sigmoid_cross_entropy(d_logits,
tf.ones_like(d_logits),
name='gfake')
g_vars = tl.layers.get_variables_with_name('generator', True, True)
d_vars = tl.layers.get_variables_with_name('discriminator', True, True)
# Define optimizers for updating discriminator and generator
d_optim = tf.train.AdamOptimizer(FLAGS.learning_rate, beta1=FLAGS.beta1) \
.minimize(d_loss, var_list=d_vars)
g_optim = tf.train.AdamOptimizer(FLAGS.learning_rate, beta1=FLAGS.beta1) \
.minimize(g_loss, var_list=g_vars)
# Init Session
sess = tf.InteractiveSession()
sess.run(tf.global_variables_initializer())
model_dir = "%s_%s_%s" % (FLAGS.dataset, FLAGS.batch_size,
FLAGS.output_size)
save_dir = os.path.join(FLAGS.checkpoint_dir, model_dir)
tl.files.exists_or_mkdir(FLAGS.sample_dir)
tl.files.exists_or_mkdir(save_dir)
# load the latest checkpoints
net_g_name = os.path.join(save_dir, 'net_g.npz')
net_d_name = os.path.join(save_dir, 'net_d.npz')
data_files = np.array(glob(os.path.join("./data", FLAGS.dataset, "*.jpg")))
num_files = len(data_files)
# Mini-batch generator
def iterate_minibatches(batch_size, shuffle=True):
if shuffle:
indices = np.random.permutation(num_files)
for start_idx in range(0, num_files - batch_size + 1, batch_size):
if shuffle:
excerpt = indices[start_idx:start_idx + batch_size]
else:
excerpt = slice(start_idx, start_idx + batch_size)
# Get real images (more image augmentation functions at [http://tensorlayer.readthedocs.io/en/latest/modules/prepro.html])
yield np.array([
get_image(file,
FLAGS.image_size,
is_crop=FLAGS.is_crop,
resize_w=FLAGS.output_size,
is_grayscale=0) for file in data_files[excerpt]
]).astype(np.float32)
batch_steps = min(num_files, FLAGS.train_size) // FLAGS.batch_size
# sample noise
sample_seed = np.random.normal(loc=0.0,
scale=1.0,
size=(FLAGS.sample_size,
z_dim)).astype(np.float32)
""" Training models """
iter_counter = 0
for epoch in range(FLAGS.epoch):
sample_images = next(iterate_minibatches(FLAGS.sample_size))
print("[*] Sample images updated!")
steps = 0
for batch_images in iterate_minibatches(FLAGS.batch_size):
batch_z = np.random.normal(loc=0.0,
scale=1.0,
size=(FLAGS.batch_size,
z_dim)).astype(np.float32)
start_time = time.time()
# Updates the Discriminator(D)
errD, _ = sess.run([d_loss, d_optim],
feed_dict={
z: batch_z,
real_images: batch_images
})
# Updates the Generator(G)
# run generator twice to make sure that d_loss does not go to zero (different from paper)
for _ in range(2):
errG, _ = sess.run([g_loss, g_optim], feed_dict={z: batch_z})
end_time = time.time() - start_time
print("Epoch: [%2d/%2d] [%4d/%4d] time: %4.4f, d_loss: %.8f, g_loss: %.8f" \
% (epoch, FLAGS.epoch, steps, batch_steps, end_time, errD, errG))
iter_counter += 1
if np.mod(iter_counter, FLAGS.sample_step) == 0:
# Generate images
img, errD, errG = sess.run([net_g2.outputs, d_loss, g_loss],
feed_dict={
z: sample_seed,
real_images: sample_images
})
# Visualize generated images
tl.visualize.save_images(
img, [num_tiles, num_tiles],
'./{}/train_{:02d}_{:04d}.png'.format(
FLAGS.sample_dir, epoch, steps))
print("[Sample] d_loss: %.8f, g_loss: %.8f" % (errD, errG))
if np.mod(iter_counter, FLAGS.save_step) == 0:
# Save current network parameters
print("[*] Saving checkpoints...")
tl.files.save_npz(net_g.all_params, name=net_g_name, sess=sess)
tl.files.save_npz(net_d.all_params, name=net_d_name, sess=sess)
print("[*] Saving checkpoints SUCCESS!")
steps += 1
sess.close()
os.mkdir(data_dir)
trainset = datasets.FashionMNIST(data_dir,
download=True,
train=True,
transform=transform)
trainset = datasets.FashionMNIST(data_dir,
download=False,
train=True,
transform=transform)
trainloader = torch.utils.data.DataLoader(trainset,
batch_size=64,
shuffle=True)
G = generator(args)
D = discriminator(args)
criterion = torch.nn.BCELoss()
d_optimizer = torch.optim.Adam(D.parameters(),
lr=args.d_lr,
betas=(args.beta, args.beta1))
g_optimizer = torch.optim.Adam(G.parameters(),
lr=args.d_lr,
betas=(args.beta, args.beta1))
for i in range(epochs):
for idx, data in enumerate(trainloader):
x = data[0].to(device)
y = data[1].to(device)
def build_gan(self):
# set if generator is going to use spectral norm
image, pc, elev, azim = self.train_source.next_batch()
elev_code = Input(shape=(1, ), name='elev_code')
azim_code = Input(shape=(1, ), name='azim_code')
pc_code = Input(shape=(self.pc_code_dim, ), name='pc_code')
noise_code = Input(shape=(self.noise_dim, ), name='noise_code')
model_name = "pc2pix"
image_size = image.shape[1]
if self.color:
input_shape = (image_size, image_size, 3)
else:
input_shape = (image_size, image_size, 1)
inputs = Input(shape=input_shape, name='image_input')
if self.gen_spectral_normalization:
optimizer = Adam(lr=4e-4, beta_1=0.0, beta_2=0.9)
else:
optimizer = Adam(lr=2e-4, beta_1=0.5, beta_2=0.999)
# build discriminator
# by default, discriminator uses SN
if self.gpus <= 1:
self.discriminator = model.discriminator(
input_shape, pc_code_dim=self.pc_code_dim)
if self.dw is not None:
print("loading discriminator weights: ", self.dw)
self.discriminator.load_weights(self.dw)
self.discriminator_single = self.discriminator
else:
with tf.device("/cpu:0"):
self.discriminator_single = model.discriminator(
input_shape, pc_code_dim=self.pc_code_dim)
if self.dw is not None:
print("loading discriminator weights: ", self.dw)
self.discriminator_single.load_weights(self.dw)
self.discriminator = multi_gpu_model(self.discriminator_single,
gpus=self.gpus)
loss = ['binary_crossentropy', 'mae', self.elev_loss, self.azim_loss]
loss_weights = [1., 10., 10., 10.]
self.discriminator.compile(loss=loss,
loss_weights=loss_weights,
optimizer=optimizer)
self.discriminator_single.summary()
path = os.path.join(self.model_dir, "discriminator.png")
plot_model(self.discriminator_single, to_file=path, show_shapes=True)
# build generator
# try SN to see if mode collapse is avoided
if self.gpus <= 1:
self.generator = model.generator(
input_shape,
noise_code=noise_code,
pc_code=pc_code,
elev_code=elev_code,
azim_code=azim_code,
spectral_normalization=self.gen_spectral_normalization,
color=self.color)
if self.gw is not None:
print("loading generator weights: ", self.gw)
self.generator.load_weights(self.gw)
self.generator_single = self.generator
else:
with tf.device("/cpu:0"):
self.generator_single = model.generator(
input_shape,
noise_code=noise_code,
pc_code=pc_code,
elev_code=elev_code,
azim_code=azim_code,
spectral_normalization=self.gen_spectral_normalization,
color=self.color)
if self.gw is not None:
print("loading generator weights: ", self.gw)
self.generator_single.load_weights(self.gw)
self.generator = multi_gpu_model(self.generator_single,
gpus=self.gpus)
self.generator_single.summary()
path = os.path.join(self.model_dir, "generator.png")
plot_model(self.generator_single, to_file=path, show_shapes=True)
self.discriminator.trainable = False
if self.gen_spectral_normalization:
optimizer = Adam(lr=1e-4, beta_1=0.0, beta_2=0.9)
else:
optimizer = Adam(lr=1e-4, beta_1=0.5, beta_2=0.999)
if self.gpus <= 1:
self.adversarial = Model(
[noise_code, pc_code, elev_code, azim_code],
self.discriminator(
self.generator([noise_code, pc_code, elev_code,
azim_code])),
name=model_name)
self.adversarial_single = self.adversarial
else:
with tf.device("/cpu:0"):
self.adversarial_single = Model(
[noise_code, pc_code, elev_code, azim_code],
self.discriminator(
self.generator(
[noise_code, pc_code, elev_code, azim_code])),
name=model_name)
self.adversarial = multi_gpu_model(self.adversarial_single,
gpus=self.gpus)
self.adversarial.compile(loss=loss,
loss_weights=loss_weights,
optimizer=optimizer)
self.adversarial_single.summary()
path = os.path.join(self.model_dir, "adversarial.png")
plot_model(self.adversarial_single, to_file=path, show_shapes=True)
print("Using split file: ", self.split_file)
print("1 epoch datalen: ", self.epoch_datalen)
print("1 epoch train steps: ", self.train_steps)
print("Using pc codes: ", self.pc_codes_filename)
def train(z_dim=None, model_name=None):
"""
Used to train the autoencoder by passing in the necessary inputs.
:param train_model: True -> Train the model, False -> Load the latest trained model and show the image grid.
:return: does not return anything
"""
X_train, y_train = datasets.create_datasets(retrain=0,
task="aae_wgan_" + str(z_dim),
num_aug=0)
batch_size = BATCH_SIZE
input_dim = X_train.shape[-1]
with tf.device("/gpu:0"):
sess = tf.Session(config=tf.ConfigProto(allow_soft_placement=True))
x_input = tf.placeholder(dtype=tf.float32,
shape=[batch_size, input_dim, input_dim, 1],
name='Input')
x_target = tf.placeholder(dtype=tf.float32,
shape=[batch_size, input_dim, input_dim, 1],
name='Target')
real_distribution = tf.placeholder(dtype=tf.float32,
shape=[batch_size, z_dim],
name='Real_distribution')
decoder_input = tf.placeholder(dtype=tf.float32,
shape=[1, z_dim],
name='Decoder_input')
encoder_output = encoder(x_input, reuse=False, is_train=True)
encoder_output_test = encoder(x_input, reuse=True, is_train=False)
d_fake, d_fake_logits = discriminator(encoder_output, reuse=False)
d_real, d_real_logits = discriminator(real_distribution, reuse=True)
d_fake_test, d_fake_logits_test = discriminator(encoder_output,
reuse=True)
d_real_test, d_real_logits_test = discriminator(real_distribution,
reuse=True)
decoder_output, std = decoder(encoder_output,
reuse=False,
is_train=True)
encoder_output_z = encoder(decoder_output, reuse=True, is_train=False)
decoder_output_test, std_ = decoder(encoder_output,
reuse=True,
is_train=False)
encoder_output_z_test = encoder(decoder_output_test,
reuse=True,
is_train=False)
#decoder_image = decoder(decoder_input, reuse=True, is_train=False)
# Autoencoder loss
# summed = tf.reduce_mean(tf.square(decoder_output-x_target),[1,2,3])
summed = tf.reduce_sum(tf.square(decoder_output - x_target), [1, 2, 3])
# sqrt_summed = summed
sqrt_summed = tf.sqrt(summed + 1e-8)
autoencoder_loss = tf.reduce_mean(sqrt_summed)
summed_test = tf.reduce_sum(tf.square(decoder_output_test - x_target),
[1, 2, 3])
# sqrt_summed_test = summed_test
sqrt_summed_test = tf.sqrt(summed_test + 1e-8)
autoencoder_loss_test = tf.reduce_mean(sqrt_summed_test)
# l2 loss of z
enc = tf.reduce_sum(tf.square(encoder_output - encoder_output_z), [1])
encoder_l2loss = tf.reduce_mean(enc)
enc_test = tf.reduce_sum(
tf.square(encoder_output_test - encoder_output_z_test), [1])
encoder_l2loss_test = tf.reduce_mean(enc_test)
dc_loss = tf.reduce_mean(d_real_logits - d_fake_logits)
dc_loss_test = tf.reduce_mean(d_real_logits_test - d_fake_logits_test)
with tf.name_scope("Gradient_penalty"):
eta = tf.placeholder(tf.float32, shape=[batch_size, 1], name="Eta")
interp = eta * real_distribution + (1 - eta) * encoder_output
_, c_interp = discriminator(interp, reuse=True)
# taking the zeroth and only element because tf.gradients returns a list
c_grads = tf.gradients(c_interp, interp)[0]
# L2 norm, reshaping to [batch_size]
slopes = tf.sqrt(tf.reduce_sum(tf.square(c_grads), axis=[1]))
tf.summary.histogram("Critic gradient L2 norm", slopes)
grad_penalty = tf.reduce_mean((slopes - 1)**2)
lambd = 10.0
dc_loss += lambd * grad_penalty
# Generator loss
# generator_loss = tf.reduce_mean(
# tf.nn.sigmoid_cross_entropy_with_logits(labels=tf.ones_like(d_fake), logits=d_fake_logits))
generator_loss = tf.reduce_mean(d_fake_logits)
generator_loss_test = tf.reduce_mean(d_fake_logits_test)
all_variables = tf.trainable_variables()
dc_var = tl.layers.get_variables_with_name('Discriminator', True, True)
en_var = tl.layers.get_variables_with_name('Encoder', True, True)
#print en_var
# dc_var = [var for var in all_variables if 'dc' in var.name]
# en_var = [var for var in all_variables if 'encoder' in var.name]
var_grad_autoencoder = tf.gradients(autoencoder_loss, all_variables)[0]
var_grad_discriminator = tf.gradients(dc_loss, dc_var)[0]
var_grad_generator = tf.gradients(generator_loss, en_var)[0]
# Optimizers
with tf.device("/gpu:0"):
autoencoderl2_optimizer = tf.train.AdamOptimizer(
learning_rate=LR, beta1=0.5,
beta2=0.9).minimize(autoencoder_loss + 0.5 * encoder_l2loss)
autoencoder_optimizer = tf.train.AdamOptimizer(
learning_rate=LR, beta1=0.5,
beta2=0.9).minimize(autoencoder_loss)
discriminator_optimizer = tf.train.AdamOptimizer(
learning_rate=LR, beta1=0.5,
beta2=0.9).minimize(dc_loss, var_list=dc_var)
generator_optimizer = tf.train.AdamOptimizer(learning_rate=LR,
beta1=0.5,
beta2=0.9).minimize(
generator_loss,
var_list=en_var)
tl.layers.initialize_global_variables(sess)
# Reshape immages to display them
input_images = tf.reshape(x_input, [-1, input_dim, input_dim, 1])
generated_images = tf.reshape(decoder_output,
[-1, input_dim, input_dim, 1])
# generated_images = tf.reshape(decoder_output, [-1, 28, 28, 1])
tensorboard_path, saved_model_path, log_path, folder_name = form_results(
)
# bp()
writer = tf.summary.FileWriter(logdir=tensorboard_path,
graph=sess.graph)
# Tensorboard visualization
tf.summary.scalar(name='Autoencoder Loss', tensor=autoencoder_loss)
tf.summary.scalar(name='Autoencoder Test Loss',
tensor=autoencoder_loss_test)
tf.summary.scalar(name='Discriminator Loss', tensor=dc_loss)
tf.summary.scalar(name='Generator Loss', tensor=generator_loss)
tf.summary.scalar(name='Autoencoder z Loss', tensor=encoder_l2loss)
tf.summary.histogram(name='Encoder Distribution',
values=encoder_output)
tf.summary.histogram(name='Real Distribution',
values=real_distribution)
tf.summary.histogram(name='Gradient AE', values=var_grad_autoencoder)
tf.summary.histogram(name='Gradient D', values=var_grad_discriminator)
tf.summary.histogram(name='Gradient G', values=var_grad_generator)
tf.summary.image(name='Input Images',
tensor=input_images,
max_outputs=10)
tf.summary.image(name='Generated Images',
tensor=generated_images,
max_outputs=10)
summary_op = tf.summary.merge_all()
saver = tf.train.Saver()
# Saving the model
step = 0
# with tf.Session() as sess:
with open(log_path + '/log.txt', 'a') as log:
log.write("input_dim: {}\n".format(input_dim))
log.write("z_dim: {}\n".format(z_dim))
log.write("batch_size: {}\n".format(batch_size))
log.write("\n")
for i in range(EPOCHS):
b = 0
for batch in tl.iterate.minibatches(inputs=X_train,
targets=np.zeros(X_train.shape),
batch_size=batch_size,
shuffle=True):
z_real_dist = np.random.normal(0, 1, (batch_size, z_dim)) * 1.
z_real_dist = z_real_dist.astype("float32")
batch_x, _ = batch
batch_x = batch_x[:, :, :, np.newaxis]
#lambda_x = np.max(lambda_grow_max / np.float(i), lambda_grow_max)
sess.run(autoencoderl2_optimizer,
feed_dict={
x_input: batch_x,
x_target: batch_x
})
if i < 20:
# sess.run(autoencoder_optimizer, feed_dict={x_input: batch_x, x_target: batch_x})
for t in range(10):
for _ in range(20):
eta1 = np.random.rand(
batch_size,
1) # sampling from uniform distribution
eta1 = eta1.astype("float32")
sess.run(discriminator_optimizer,
feed_dict={
x_input: batch_x,
x_target: batch_x,
real_distribution: z_real_dist,
eta: eta1
})
else:
# sess.run(autoencoderl2_optimizer, feed_dict={x_input: batch_x, x_target: batch_x})
for _ in range(20):
eta1 = np.random.rand(
batch_size, 1) # sampling from uniform distribution
eta1 = eta1.astype("float32")
sess.run(discriminator_optimizer,
feed_dict={
x_input: batch_x,
x_target: batch_x,
real_distribution: z_real_dist,
eta: eta1
})
sess.run(generator_optimizer,
feed_dict={
x_input: batch_x,
x_target: batch_x
})
if b % 50 == 0:
a_loss, e_loss, d_loss, g_loss, a_grad, d_grad, g_grad, en_output, d_real_logits_, d_fake_logits_, de_output, summary = sess.run(
[
autoencoder_loss, encoder_l2loss, dc_loss,
generator_loss, var_grad_autoencoder,
var_grad_discriminator, var_grad_generator,
encoder_output, d_real_logits, d_fake_logits,
decoder_output, summary_op
],
feed_dict={
x_input: batch_x,
x_target: batch_x,
real_distribution: z_real_dist,
eta: eta1
})
print(model_name)
saver.save(sess, save_path=saved_model_path, global_step=step)
writer.add_summary(summary, global_step=step)
print("Epoch: {}, iteration: {}".format(i, b))
print("Autoencoder Loss: {}".format(a_loss))
print("Autoencoder enc Loss: {}".format(e_loss))
print("Discriminator Loss: {}".format(d_loss))
print("Generator Loss: {}".format(g_loss))
with open(log_path + '/log.txt', 'a') as log:
log.write("Epoch: {}, iteration: {}\n".format(i, b))
log.write("Autoencoder Loss: {}\n".format(a_loss))
log.write("Autoencoder enc Loss: {}\n".format(e_loss))
log.write("Discriminator Loss: {}\n".format(d_loss))
log.write("Generator Loss: {}\n".format(g_loss))
b += 1
step += 1
b = 0
for batch in tl.iterate.minibatches(inputs=y_train,
targets=np.zeros(y_train.shape),
batch_size=batch_size,
shuffle=True):
z_real_dist = np.random.normal(0, 1, (batch_size, z_dim)) * 1.
z_real_dist = z_real_dist.astype("float32")
batch_x, _ = batch
batch_x = batch_x[:, :, :, np.newaxis]
eta1 = np.random.rand(batch_size, 1)
if b % 20 == 0:
a_loss, e_loss, d_loss, g_loss = sess.run(
[
autoencoder_loss_test, encoder_l2loss_test,
dc_loss_test, generator_loss_test
],
feed_dict={
x_input: batch_x,
x_target: batch_x,
real_distribution: z_real_dist,
eta: eta1
})
print("v_Epoch: {}, iteration: {}".format(i, b))
print("v_Autoencoder Loss: {}".format(a_loss))
print("v_Autoencoder enc Loss: {}".format(e_loss))
print("v_Discriminator Loss: {}".format(d_loss))
print("v_Generator Loss: {}".format(g_loss))
with open(log_path + '/log.txt', 'a') as log:
log.write("v_Epoch: {}, iteration: {}\n".format(i, b))
log.write("v_Autoencoder Loss: {}\n".format(a_loss))
log.write("v_Autoencoder enc Loss: {}\n".format(e_loss))
log.write("v_Discriminator Loss: {}\n".format(d_loss))
log.write("v_Generator Loss: {}\n".format(g_loss))
with tf.device('/cpu:0'):
images, labels = train_inputs(batch_size)
images_test, labels_test = test_inputs(batch_size)
with tf.variable_scope('placeholder'):
X = tf.placeholder(tf.float32, [None, IMAGE_SIZE, IMAGE_SIZE, 3])
z = tf.placeholder(tf.float32, [None, 100]) # noise
y = tf.placeholder(name='label', dtype=tf.float32, shape=[batch_size, 10])
keep_prob = tf.placeholder(tf.float32, shape=())
is_train = tf.placeholder(tf.bool, shape=())
with tf.variable_scope('GAN'):
G = generator(z, keep_prob=keep_prob, is_train=is_train)
D_real, D_real_logits, flat_features = discriminator(X,
keep_prob=keep_prob,
is_train=is_train,
reuse=False)
D_fake, D_fake_logits, flat_features = discriminator(G,
keep_prob=keep_prob,
is_train=is_train,
reuse=True)
with tf.variable_scope('D_loss'):
real_label = tf.concat([0.89 * y, tf.zeros([batch_size, 1])], axis=1)
real_label += 0.01 * tf.ones([batch_size, 11])
fake_label = tf.concat(
[tf.zeros([batch_size, 10]),
tf.ones([batch_size, 1])], axis=1)
d_loss_real = tf.reduce_mean(
