def generate(file_list, data_dir, output_dir, context_len=32, stats=None,
base_model_path='./pls.model', gan_model_path='./noise_gen.model'):
pulse_model = time_glot_model(timesteps=context_len)
gan_model = generator()
pulse_model.compile(loss='mse', optimizer="adam")
gan_model.compile(loss='mse', optimizer="adam")
pulse_model.load_weights(base_model_path)
gan_model.load_weights(gan_model_path)
for data in nc_data_provider(file_list, data_dir, input_only=True,
context_len=context_len):
for fname, ac_data in data.iteritems():
print fname
pls_pred, _ = pulse_model.predict([ac_data])
noise = np.random.randn(pls_pred.shape[0], pls_pred.shape[1])
pls_gan, _ = gan_model.predict([pls_pred, noise])
out_file = os.path.join(args.output_dir, fname + '.pls')
pls_gan.astype(np.float32).tofile(out_file)
out_file = os.path.join(args.output_dir, fname + '.pls_nonoise')
pls_pred.astype(np.float32).tofile(out_file)
def generate(args):
# Context
ctx = get_extension_context(args.context,
device_id=args.device_id,
type_config=args.type_config)
nn.set_default_context(ctx)
# Args
latent = args.latent
maps = args.maps
batch_size = args.batch_size
# Generator
nn.load_parameters(args.model_load_path)
z_test = nn.Variable([batch_size, latent])
x_test = generator(z_test, maps=maps, test=True, up=args.up)
# Monitor
monitor = Monitor(args.monitor_path)
monitor_image_tile_test = MonitorImageTile("Image Tile Generated",
monitor,
num_images=batch_size,
interval=1,
normalize_method=denormalize)
# Generation iteration
for i in range(args.num_generation):
z_test.d = np.random.randn(batch_size, latent)
x_test.forward(clear_buffer=True)
monitor_image_tile_test.add(i, x_test)
def test(classifier, generator, data_loader, dataset="MNIST"):
"""Evaluate classifier on source or target domains."""
# set eval state for Dropout and BN layers
generator.eval()
classifier.eval()
# init loss and accuracy
loss = 0
acc = 0
# set loss function
criterion = nn.CrossEntropyLoss()
# evaluate network
for (images, labels) in data_loader:
images = Variable(images, volatile=True)
labels = Variable(labels.squeeze_())
if use_cuda:
images = images.cuda()
labels = labels.cuda()
preds = classifier(generator(images))
loss += criterion(preds, labels).data[0]
pred_cls = preds.data.max(1)[1]
acc += pred_cls.eq(labels.data).cpu().sum()
loss /= len(data_loader)
acc /= len(data_loader.dataset)
print("Avg Loss = {:.5f}, Avg Accuracy = {:2.5%}".format(loss, acc))
def reconstruct_time_series_monthly(images_fn, weights_fn, out_dir,
time_range, application="mchrzc", ds_factor=16, n_ensemble=4,
relax_lam=0.0):
(gen,_) = models.generator(num_timesteps=1)
init_model = models.initial_state_model()
(gen_init, noise_shapes) = models.generator_initialized(gen, init_model,
num_timesteps=1)
gen_init.load_weights(weights_fn)
t0 = time_range[0]
months = []
while t0 < time_range[1]:
(y,m) = (t0.year, t0.month)
m += 1
if m > 12:
m = 1
y += 1
t1 = datetime(y,m,1)
months.append((t0,t1))
t0 = t1
(h, last_t) = (None, None)
for month in months:
out_fn = out_dir + "/timeseries-{}-{}{:02d}.nc".format(
application,month[0].year,month[0].month)
(h, last_t) = reconstruct_time_series_partial(images_fn, gen,
noise_shapes, init_model, out_fn, month, h=h, last_t=last_t,
application=application, ds_factor=ds_factor, n_ensemble=n_ensemble,
relax_lam=relax_lam
)
def sample_dcgan(side_len):
"""
Runs inference on the generator.
:param int side_len:
Side length for generator output (must match `crop_len`).
"""
# only need to restore the generator's variables
G = generator(sample, None, side_len)
sess = tf.Session()
sess.run(tf.initialize_all_variables())
# apply the trained generator weights
saver = tf.train.Saver()
chkpt_fname = tf.train.latest_checkpoint(OUTPUT_PATH)
saver.restore(sess, chkpt_fname)
# run a forward pass
vec = np.random.normal(size=(batch_size, Z_SIZE))
result = sess.run(G, {sample: vec})
# save the result
_deprocess_and_save(result, -1)
def sample_dcgan(side_len):
"""
Runs inference on the generator.
:param int side_len:
Side length for generator output (must match `crop_len`).
"""
# only need to restore the generator's variables
G = generator(sample, None, side_len)
sess = tf.Session()
sess.run(tf.initialize_all_variables())
# apply the trained generator weights
saver = tf.train.Saver()
chkpt_fname = tf.train.latest_checkpoint(OUTPUT_PATH)
saver.restore(sess, chkpt_fname)
# run a forward pass
vec = np.random.normal(size=(batch_size, Z_SIZE))
result = sess.run(G, {sample: vec})
# save the result
_deprocess_and_save(result, -1)
def main():
"""
Inference function to generate SR images.
"""
nn.load_parameters(args.model)
# Inference data loader
inference_data = inference_data_loader(args.input_dir_lr)
input_shape = [
1,
] + list(inference_data.inputs[0].shape)
output_shape = [1, input_shape[1] * 4, input_shape[2] * 4, 3]
oh = input_shape[1] - input_shape[1] // 8 * 8
ow = input_shape[2] - input_shape[2] // 8 * 8
# Build the computation graph
inputs_raw = nn.Variable(input_shape)
pre_inputs = nn.Variable(input_shape)
pre_gen = nn.Variable(output_shape)
pre_warp = nn.Variable(output_shape)
transposed_pre_warp = space_to_depth(pre_warp)
inputs_all = F.concatenate(inputs_raw, transposed_pre_warp)
with nn.parameter_scope("generator"):
gen_output = generator(inputs_all, 3, args.num_resblock)
outputs = (gen_output + 1) / 2
inputs_frames = F.concatenate(pre_inputs, inputs_raw)
with nn.parameter_scope("fnet"):
flow_lr = flow_estimator(inputs_frames)
flow_lr = F.pad(flow_lr, (0, 0, 0, oh, 0, ow, 0, 0), "reflect")
flow_hr = upscale_four(flow_lr * 4.0)
pre_gen_warp = warp_by_flow(pre_gen, flow_hr)
if not os.path.exists(args.output_dir):
os.makedirs(args.output_dir)
max_iter = len(inference_data.inputs)
print('Frame evaluation starts!!')
pre_inputs.d, pre_gen.d, pre_warp.d = 0, 0, 0
for i in range(max_iter):
inputs_raw.d = np.array([inference_data.inputs[i]]).astype(np.float32)
if i != 0:
pre_gen_warp.forward()
pre_warp.data.copy_from(pre_gen_warp.data)
outputs.forward()
output_frame = outputs.d
if i >= 5:
name, _ = os.path.splitext(
os.path.basename(str(inference_data.paths_lr[i])))
filename = args.output_name + '_' + name
print('saving image %s' % filename)
out_path = os.path.join(args.output_dir,
"%s.%s" % (filename, args.output_ext))
save_img(out_path, output_frame[0])
else: # First 5 is a hard-coded symmetric frame padding, ignored but time added!
print("Warming up %d" % (5 - i))
pre_inputs.data.copy_from(inputs_raw.data)
pre_gen.data.copy_from(outputs.data)
def evaluate(args):
# Context
ctx = get_extension_context(args.context,
device_id=args.device_id,
type_config=args.type_config)
nn.set_default_context(ctx)
# Args
latent = args.latent
maps = args.maps
batch_size = args.batch_size
image_size = args.image_size
n_classes = args.n_classes
not_sn = args.not_sn
# Model (Inception model) from nnp file
nnp = NnpLoader(args.nnp_inception_model_load_path)
x, y = get_input_and_output(nnp, args.batch_size, name=args.variable_name)
if args.evaluation_metric == "IS":
is_model = None
compute_metric = compute_inception_score
if args.evaluation_metric == "FID":
di = data_iterator_imagenet(args.valid_dir,
args.dirname_to_label_path,
batch_size=args.batch_size,
ih=args.image_size,
iw=args.image_size,
shuffle=True,
train=False,
noise=False)
compute_metric = functools.partial(compute_frechet_inception_distance,
di=di)
# Monitor
monitor = Monitor(args.monitor_path)
monitor_metric = MonitorSeries("{}".format(args.evaluation_metric),
monitor,
interval=1)
# Compute the evaluation metric for all models
def cmp_func(path):
return int(path.split("/")[-1].strip("params_").rstrip(".h5"))
model_load_path = sorted(glob.glob("{}/*.h5".format(args.model_load_path)), key=cmp_func) \
if os.path.isdir(args.model_load_path) else \
[args.model_load_path]
for path in model_load_path:
# Model (SAGAN)
nn.load_parameters(path)
z = nn.Variable([batch_size, latent])
y_fake = nn.Variable([batch_size])
x_fake = generator(z, y_fake, maps=maps, n_classes=n_classes, test=True, sn=not_sn)\
.apply(persistent=True)
# Compute the evaluation metric
score = compute_metric(z, y_fake, x_fake, x, y, args)
itr = cmp_func(path)
monitor_metric.add(itr, score)
def __generate(self, input, scale):
pad_size = int(self.config["ker_size"] * self.config["num_layer"] *
0.5)
paddings = tf.constant([[0, 0], [pad_size, pad_size],
[pad_size, pad_size], [0, 0]])
x = tf.pad(input, paddings, "CONSTANT")
return models.generator(x,
input,
self.config,
name="scale_" + str(scale))
def init_generator(self, encoder, decoder, name=None, lr=2e-4, beta_1=.5):
'''
Creates a generator.
'''
generator = m.generator(encoder,
decoder,
img_size=self.img_size,
name=name)
optimizer = tf.keras.optimizers.Adam(lr, beta_1=beta_1)
gradients = None
return generator, optimizer, gradients
def train(epochs, batch_size, ckpt_path, imgs_path, lr, out_path):
tf.keras.backend.clear_session()
train_data = get_data(imgs_path, batch_size)
gen = generator()
disc = discriminator()
print(gen.summary())
print(disc.summary())
gen_opt = Adam(learning_rate=lr, beta_1=0.5)
disc_opt = Adam(learning_rate=lr, beta_1=0.5)
ckpt = Checkpoint(disc=disc, gen=gen, disc_opt=disc_opt, gen_opt=gen_opt)
manager = CheckpointManager(ckpt, ckpt_path, max_to_keep=3)
if manager.latest_checkpoint:
print("Restored from {}".format(manager.latest_checkpoint))
ckpt.restore(manager.latest_checkpoint)
else:
print("Initializing from scratch.")
seed = tf.random.normal([16, ENCODING_SIZE], seed=1234)
generate_and_save_images(gen, 0, seed, out_path)
for ep in range(epochs):
gen_loss = []
disc_loss_real = []
disc_loss_fake = []
print('Epoch: %d of %d' % (ep + 1, epochs))
start = time.time()
for images in train_data:
g_loss, d_loss_r, d_loss_f = train_step(images, gen, disc, gen_opt,
disc_opt, batch_size)
gen_loss.append(g_loss)
disc_loss_real.append(d_loss_r)
disc_loss_fake.append(d_loss_f)
gen_loss = np.mean(np.asarray(gen_loss))
disc_loss_real = np.mean(np.asarray(disc_loss_real))
disc_loss_fake = np.mean(np.asarray(disc_loss_fake))
if (np.isnan(gen_loss) or np.isnan(disc_loss_real)
or np.isnan(disc_loss_fake)):
print("Something broke.")
break
manager.save()
generate_and_save_images(gen, ep + 1, seed, out_path)
print("Time for epoch:", time.time() - start)
print("Gen loss=", gen_loss)
print("Disc loss real=", disc_loss_real)
print("Disc loss fake=", disc_loss_fake)
def predict(img_path):
# example pathgan.predict('/root/sharedfolder/Images/P1.jpg')
loss_weights = [1., 0.05] #0.05
adversarial_iteration = 2
batch_size = 40 #100
mini_batch_size = 800 #4000
G = 1
epochs = 200
n_hidden_gen = 1000
lr = 1e-4
content_loss = 'mse'
lstm_activation = 'tanh'
dropout = 0.1
dataset_path = '/root/sharedfolder/predict_scanpaths/finetune_saltinet_isun/input/salient360_EVAL_noTime.hdf5'
model360 = 'false'
weights_generator = '../weights/generator_single_weights.h5'
opt = RMSprop(lr=lr, rho=0.9, epsilon=1e-08, decay=0.0)
# Load image
img, img_size = utils.load_image(img_path, 'small_images')
# Get the model
params = {
'n_hidden_gen': n_hidden_gen,
'lstm_activation': lstm_activation,
'dropout': dropout,
'optimizer': opt,
'loss': content_loss,
'weights': weights_generator,
'G': G
}
_, generator_parallel = models.generator(**params)
# Predict with a model
n_sp_per_image = 1
#provisional
output = np.zeros((n_sp_per_image, 63, 4))
for i in range(n_sp_per_image):
print("Calculating observer %d" % i)
noise = np.random.normal(0, 3, img.shape)
noisy_img = img + noise
prediction = generator_parallel.predict(noisy_img)
output[i] = prediction
# Prepare the predictions for matlab and save it on individual files
output = prepare_image(output[:, :, :])
return output
def morph(args):
# Communicator and Context
extension_module = "cudnn"
ctx = get_extension_context(extension_module, type_config=args.type_config)
nn.set_default_context(ctx)
# Args
latent = args.latent
maps = args.maps
batch_size = args.batch_size
image_size = args.image_size
n_classes = args.n_classes
not_sn = args.not_sn
threshold = args.truncation_threshold
# Model
nn.load_parameters(args.model_load_path)
z = nn.Variable([batch_size, latent])
alpha = nn.Variable.from_numpy_array(np.zeros([1, 1]))
beta = (nn.Variable.from_numpy_array(np.ones([1, 1])) - alpha)
y_fake_a = nn.Variable([batch_size])
y_fake_b = nn.Variable([batch_size])
x_fake = generator(z, [y_fake_a, y_fake_b],
maps=maps,
n_classes=n_classes,
test=True,
sn=not_sn,
coefs=[alpha, beta]).apply(persistent=True)
b, c, h, w = x_fake.shape
# Monitor
monitor = Monitor(args.monitor_path)
name = "Morphed Image {} {}".format(args.from_class_id, args.to_class_id)
monitor_image = MonitorImage(name,
monitor,
interval=1,
num_images=1,
normalize_method=normalize_method)
# Morph
images = []
z_data = resample(batch_size, latent, threshold)
z.d = z_data
for i in range(args.n_morphs):
alpha.d = 1.0 * i / args.n_morphs
y_fake_a.d = generate_one_class(args.from_class_id, batch_size)
y_fake_b.d = generate_one_class(args.to_class_id, batch_size)
x_fake.forward(clear_buffer=True)
monitor_image.add(i, x_fake.d)
def get_generator_output(conf, rnn_length, r_inputs, flow_hr, scope_name):
"""
Return the generated HR frames
"""
# list for all outputs
gen_outputs = []
# for the first frame, concat with zeros
input0 = F.concatenate(
r_inputs[:, 0, :, :, :],
F.constant(0, (conf.train.batch_size, conf.train.crop_size,
conf.train.crop_size, 3 * 4 * 4)))
with nn.parameter_scope(scope_name + "generator"):
gen_pre_output = generator(input0, 3, conf.train.num_resblock)
gen_outputs.append(gen_pre_output) # append generated HR frame-0
for frame_i in range(rnn_length - 1):
cur_flow = flow_hr[:, frame_i, :, :, :]
# warp the previously generated frame
gen_pre_output_warp = warp_by_flow(gen_pre_output, cur_flow)
gen_pre_output_warp = F.identity(deprocess(gen_pre_output_warp))
# apply space-to-depth transform
gen_pre_output_warp = space_to_depth(gen_pre_output_warp)
# pack it as the recurrent input
inputs = F.concatenate(r_inputs[:, frame_i + 1, :, :, :],
gen_pre_output_warp)
# super-resolution part
with nn.parameter_scope(scope_name + "generator"):
gen_output = generator(inputs, 3, conf.train.num_resblock)
gen_outputs.append(gen_output)
gen_pre_output = gen_output
# gen_outputs, a list, len = frame, shape = (batch, FLAGS.crop_size*4, FLAGS.crop_size*4, 3)
gen_outputs = F.stack(*gen_outputs, axis=1)
# gen_outputs, nn.Variable with shape = (batch, frame, FLAGS.crop_size*4, FLAGS.crop_size*4, 3)
return gen_outputs
def train(args):
train_ds, test_ds = get_data(args.img_path, args.batch)
gen = generator()
disc = discriminator()
gen_opt = Adam(args.learning_rate, beta_1=0.5, beta_2=0.999)
disc_opt = Adam(args.learning_rate, beta_1=0.5, beta_2=0.999)
print(gen.summary())
print(disc.summary())
ckpt = Checkpoint(disc=disc, gen=gen, disc_opt=disc_opt, gen_opt=gen_opt)
manager = CheckpointManager(ckpt, args.ckpt_path, max_to_keep=3)
if args.continue_training:
latest = manager.latest_checkpoint
if latest:
print("Restored from {}".format(latest))
ckpt.restore(latest)
off = int(re.split('-', latest)[-1])
else:
off = 0
print("Initializing from scratch.")
for ep in range(args.epochs):
for x, y in test_ds.take(1):
generate_and_save_imgs(gen, ep + off, x, y, args.out_path)
gen_loss = []
disc_loss = []
print('Epoch: %d of %d' % (ep + 1 + off, args.epochs + off))
start = time.time()
for x, y in train_ds:
g_loss, d_loss = train_step(x, y, gen, disc, gen_opt, disc_opt,
args.batch)
gen_loss.append(g_loss)
disc_loss.append(d_loss)
gen_loss = np.mean(np.asarray(gen_loss))
disc_loss = np.mean(np.asarray(disc_loss))
manager.save()
print("Time for epoch:", time.time() - start)
print("Gen loss=", gen_loss)
print("Disc loss=", disc_loss)
# Storing three different outputs after final epoch
for x, y in test_ds.take(3):
generate_and_save_imgs(gen, args.epochs + off, x, y, args.out_path)
off += 1
def train_step(images):
noise = tf.random.normal([batch_size, noise_dim])
with tf.GradientTape() as gen_tape, tf.GradientTape() as disc_tape:
generated_images = generator(noise, training=True)
real_output = discriminator(images, training=True)
fake_output = discriminator(generated_images, training=True)
gen_loss = generator_loss(fake_output)
disc_loss = discriminator_loss(real_output, fake_output)
gradients_of_generator = gen_tape.gradient(gen_loss, generator.trainable_variables)
gradients_of_discriminator = disc_tape.gradient(disc_loss, discriminator.trainable_variables)
generator_optimizer.apply_gradients(zip(gradients_of_generator, generator.trainable_variables))
discriminator_optimizer.apply_gradients(zip(gradients_of_discriminator, discriminator.trainable_variables))
def generate():
BATCH_SIZE = 2
GENERATOR_PARAMS = 100
opt = Adam(lr=0.0002, beta_1=0.5, beta_2=0.999, epsilon=1e-08, decay=0.0)
discriminator = models.discriminator()
discriminator.compile(loss='binary_crossentropy', optimizer=opt)
discriminator.load_weights('discriminator')
generator = models.generator()
generator.compile(loss='binary_crossentropy', optimizer=opt)
generator.load_weights('generator')
noise = np.zeros((BATCH_SIZE * 20, GENERATOR_PARAMS))
for i in range(BATCH_SIZE * 20):
noise[i, :] = np.random.uniform(-1, 1, GENERATOR_PARAMS)
generated_images = np.zeros((20 * BATCH_SIZE, 128, 128, 1))
for i in range(BATCH_SIZE * 20):
generated_images[i, ...] = generator.predict(np.reshape(
noise[i, :], (1, GENERATOR_PARAMS)),
verbose=1)
# d_pret = discriminator.predict(generated_images, verbose=1)
#
# index = np.arange(0, BATCH_SIZE * 20)
# index.resize((BATCH_SIZE * 20, 1))
# pre_with_index = list(np.append(d_pret, index, axis=1))
# pre_with_index.sort(key=lambda x: x[0], reverse=True)
# nice_images = np.zeros((BATCH_SIZE, 1) + (generated_images.shape[2:]), dtype=np.float32)
for i in range(len(generated_images)):
plt.imshow(generated_images[i, :, :, 0])
plt.axis('off')
plt.savefig('E:/deep-neurons/generated-' + str(i) + '.png')
plt.clf()
gif_path = args.gif
save_path = args.save_path
duration = args.duration
dataset = args.dataset
direction = args.direction
crop_size = args.crop_size
assert direction == 'a2b' or direction == 'b2a', 'Direction should be a2b or b2a!'
""" run """
frames = []
a_reals_ipt_ori = gif_frames(Image.open(gif_path))
size_ori = a_reals_ipt_ori.shape[0:3]
with tf.Session() as sess:
a_real = tf.placeholder(tf.float32,
shape=[None, crop_size, crop_size, crop_size, 3])
a2b = models.generator(a_real, direction)
# retore
saver = tf.train.Saver()
ckpt_path = utils.load_checkpoint('./checkpoints/' + dataset, sess, saver)
if ckpt_path is None:
raise Exception('No checkpoint!')
else:
print('Copy variables from % s' % ckpt_path)
a_real_ipt = np.zeros(
(1, len(a_real_ipt_ori), crop_size, crop_size, crop_size, 3))
a_real_ipt[0, ...] = im.imresize(a_real_ipt_ori,
[crop_size, crop_size, crop_size])
a2b_opt = sess.run(a2b, feed_dict={a_real: a_real_ipt})
a2b_opt_ori = im.imresize(a2b_opt[0, ..., 0].squeeze(), size_ori)
def train_dcgan(n_epochs, batch_size, lr_rate, crop_len, scale_len, restore,
paths):
"""
Train DCGAN.
:param int n_epochs:
Total number of epochs over the input data to train for.
:param int batch_size:
Batch size to use for training.
:param float lr_rate:
Generator learning rate.
:param int crop_len:
Image side length to use.
:param int scale_len:
Amount to scale the minimum side length to (for augmentation).
:param bool restore:
Specifies whether or not the latest checkpoint should be used.
:param list paths:
List of paths to images to use for training.
"""
assert scale_len >= crop_len, "invalid resize or crop length"
# create placeholders
sample = tf.placeholder(tf.float32,
shape=[batch_size, Z_SIZE],
name="sample")
real = tf.placeholder(tf.float32,
shape=[batch_size, 64, 64, 3],
name="real")
is_train = tf.placeholder(tf.bool, name="is_train")
# instantiate the models
G = generator(sample, is_train, crop_len)
D_fake = discriminator(G, is_train)
tf.get_variable_scope().reuse_variables()
D_real = discriminator(real, is_train)
# create losses
loss_G = _sigmoid_loss(D_fake, tf.ones_like(D_fake))
loss_D = _sigmoid_loss(D_fake, tf.zeros_like(D_fake)) + \
_sigmoid_loss(D_real, tf.ones_like(D_real))
# acquire tensors for generator and discriminator
# trick from carpedm20's implementation on github
g_vars = [var for var in tf.trainable_variables() if "g_" in var.name]
d_vars = [var for var in tf.trainable_variables() if "d_" in var.name]
# create optimization objectives
global_step = tf.Variable(0, name="global_step", trainable=False)
opt_G = tf.train.AdamOptimizer(lr_rate,
beta1=0.5).minimize(loss_G, var_list=g_vars)
opt_D = tf.train.AdamOptimizer(2e-4, beta1=0.5).minimize(loss_D,
var_list=d_vars)
# create a saver and restore variables, if necessary
saver = tf.train.Saver()
model_path = os.path.join(OUTPUT_PATH, CHECKPOINT_NAME)
# do some initialization
sess = tf.Session()
sess.run(tf.initialize_all_variables())
if restore:
chkpt_fname = tf.train.latest_checkpoint(OUTPUT_PATH)
saver.restore(sess, chkpt_fname)
else:
_clean_directory(OUTPUT_PATH)
_clean_directory(OUTPUT_PATH)
# reference vector (to examine epoch-to-epoch changes)
vec_ref = np.random.normal(size=(batch_size, Z_SIZE))
# begin training
n_iterations = len(paths) // batch_size
for epoch in range(sess.run(global_step), n_epochs):
print("------- EPOCH {0} -------".format(epoch))
random.shuffle(paths)
# train the discriminator for one epoch
for i in range(n_iterations):
offset = (i * batch_size) % len(paths)
batch_paths = paths[offset:(offset + batch_size)]
imgs = _read_and_preprocess(batch_paths, scale_len, crop_len)
vec = np.random.normal(size=(batch_size, Z_SIZE))
# minimize generator loss
if i % TRAIN_RATIO == TRAIN_RATIO - 1:
sess.run(opt_G, feed_dict={sample: vec, is_train: True})
# minimize discriminator loss
sess.run(opt_D,
feed_dict={
real: imgs,
sample: vec,
is_train: True
})
# log the error
if i % DISPLAY_LOSSES == 0:
err_G = sess.run(loss_G,
feed_dict={
sample: vec,
is_train: False
})
err_D = sess.run(loss_D,
feed_dict={
real: imgs,
sample: vec,
is_train: False
})
print(" Iteration {0}".format(i))
print(" generator loss = {0}".format(err_G))
print(" discriminator loss = {0}".format(err_D))
# save the model and sample results at the end of each epoch
sess.run(tf.assign(global_step, epoch + 1))
saver.save(sess, model_path, global_step=global_step)
batch_res = sess.run(G, {sample: vec_ref, is_train: False})
_deprocess_and_save(batch_res, epoch)
def train_dcgan(n_epochs, batch_size, lr_rate, crop_len, scale_len, restore, paths):
"""
Train DCGAN.
:param int n_epochs:
Total number of epochs over the input data to train for.
:param int batch_size:
Batch size to use for training.
:param float lr_rate:
Generator learning rate.
:param int crop_len:
Image side length to use.
:param int scale_len:
Amount to scale the minimum side length to (for augmentation).
:param bool restore:
Specifies whether or not the latest checkpoint should be used.
:param list paths:
List of paths to images to use for training.
"""
assert scale_len >= crop_len, "invalid resize or crop length"
# create placeholders
sample = tf.placeholder(tf.float32, shape=[batch_size, Z_SIZE], name="sample")
real = tf.placeholder(tf.float32, shape=[batch_size, 64, 64, 3], name="real")
is_train = tf.placeholder(tf.bool, name="is_train")
# instantiate the models
G = generator(sample, is_train, crop_len)
D_fake = discriminator(G, is_train)
tf.get_variable_scope().reuse_variables()
D_real = discriminator(real, is_train)
# create losses
loss_G = _sigmoid_loss(D_fake, tf.ones_like(D_fake))
loss_D = _sigmoid_loss(D_fake, tf.zeros_like(D_fake)) + \
_sigmoid_loss(D_real, tf.ones_like(D_real))
# acquire tensors for generator and discriminator
# trick from carpedm20's implementation on github
g_vars = [var for var in tf.trainable_variables() if "g_" in var.name]
d_vars = [var for var in tf.trainable_variables() if "d_" in var.name]
# create optimization objectives
global_step = tf.Variable(0, name="global_step", trainable=False)
opt_G = tf.train.AdamOptimizer(lr_rate, beta1=0.5).minimize(loss_G, var_list=g_vars)
opt_D = tf.train.AdamOptimizer(2e-4, beta1=0.5).minimize(loss_D, var_list=d_vars)
# create a saver and restore variables, if necessary
saver = tf.train.Saver()
model_path = os.path.join(OUTPUT_PATH, CHECKPOINT_NAME)
# do some initialization
sess = tf.Session()
sess.run(tf.initialize_all_variables())
if restore:
chkpt_fname = tf.train.latest_checkpoint(OUTPUT_PATH)
saver.restore(sess, chkpt_fname)
else:
_clean_directory(OUTPUT_PATH)
_clean_directory(OUTPUT_PATH)
# reference vector (to examine epoch-to-epoch changes)
vec_ref = np.random.normal(size=(batch_size, Z_SIZE))
# begin training
n_iterations = len(paths) // batch_size
for epoch in range(sess.run(global_step), n_epochs):
print("------- EPOCH {0} -------".format(epoch))
random.shuffle(paths)
# train the discriminator for one epoch
for i in range(n_iterations):
offset = (i * batch_size) % len(paths)
batch_paths = paths[offset:(offset + batch_size)]
imgs = _read_and_preprocess(batch_paths, scale_len, crop_len)
vec = np.random.normal(size=(batch_size, Z_SIZE))
# minimize generator loss
if i % TRAIN_RATIO == TRAIN_RATIO - 1:
sess.run(opt_G, feed_dict={sample: vec, is_train: True})
# minimize discriminator loss
sess.run(opt_D, feed_dict={real: imgs, sample: vec, is_train: True})
# log the error
if i % DISPLAY_LOSSES == 0:
err_G = sess.run(loss_G, feed_dict={sample: vec, is_train: False})
err_D = sess.run(loss_D, feed_dict={real: imgs, sample: vec, is_train: False})
print(" Iteration {0}".format(i))
print(" generator loss = {0}".format(err_G))
print(" discriminator loss = {0}".format(err_D))
# save the model and sample results at the end of each epoch
sess.run(tf.assign(global_step, epoch + 1))
saver.save(sess, model_path, global_step=global_step)
batch_res = sess.run(G, {sample: vec_ref, is_train: False})
_deprocess_and_save(batch_res, epoch)
def main(DATASET, data_size, num_train_epochs, num_disc_steps, num_gen_steps, batch_size, save_checkpoint_every, generate_samples_every, flip_alpha, restore = False):
loader = load_Data_new.DataLoader(DATASET)
# Create Placeholders for Data
X = tf.placeholder(tf.float32, shape = [None, 64, 64, 3])
Z = tf.placeholder(tf.float32, shape = [None, 100])
labels_d_fake = tf.placeholder(tf.float32)
labels_d_real = tf.placeholder(tf.float32)
with tf.variable_scope("gen"):
GZ = generator(Z)
with tf.variable_scope("disc") as scope:
DGZ_raw, DGZ = discriminator(GZ)
scope.reuse_variables()
DX_raw, DX = discriminator(X)
with tf.variable_scope("loss_calculation"):
# using Sigmoid Cross Entropy as loss function
# discriminator tries to discriminate between X and GZ:
# if input to discriminator is X then output prob should be 0
# if input to discriminator is GZ then output prob should be 1
# loss_d_fake = log(1-DGZ_raw)
loss_d_fake = tf.nn.sigmoid_cross_entropy_with_logits(labels=labels_d_fake, logits=DGZ_raw)
# loss_d_real = log(DX_raw)
loss_d_real = tf.nn.sigmoid_cross_entropy_with_logits(labels=labels_d_real, logits=DX_raw)
loss_g = tf.nn.sigmoid_cross_entropy_with_logits(labels=tf.ones_like(DGZ_raw), logits=DGZ_raw)
# loss_disc = log(1-DGZ_raw) + log(DX_raw)
loss_disc = tf.reduce_mean(loss_d_fake + loss_d_real)
# gen tries to fool D
# that is D should output 0 on seeing GZ
# therefore we minimize DGZ-raw(to make it 0)
# loss_gen = log(DGZ_raw)
loss_gen = tf.reduce_mean(loss_g)
GZ_summary = tf.summary.image('GZ', GZ, max_outputs = 10)
DGZ_summary = tf.summary.scalar('DGZ', tf.reduce_mean(DGZ))
DX_summary = tf.summary.scalar('DX', tf.reduce_mean(DX))
loss_disc_summary = tf.summary.scalar('loss_disc', loss_disc)
loss_gen_summary = tf.summary.scalar('loss_gen', loss_gen)
disc_merged = tf.summary.merge([DGZ_summary, DX_summary, loss_disc_summary, GZ_summary])
gen_merged = tf.summary.merge([DGZ_summary, loss_gen_summary])
# Defined Optimizers for both Discriminator and Generator
optimizer_disc = tf.train.AdamOptimizer(learning_rate=2e-4, beta1 = 0.5)
train_op_disc = optimizer_disc.minimize(loss_disc, var_list=tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES, "disc"))
optimizer_gen = tf.train.AdamOptimizer(learning_rate=2e-4, beta1 = 0.5)
train_op_gen = optimizer_gen.minimize(loss_gen, var_list=tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES, "gen"))
TAG = 'plotting-graphs_alpha_'+str(flip_alpha)+'_'+DATASET
saver = tf.train.Saver(max_to_keep=2)
if(DATASET != 'CELEBA'):
Xsample_val_set = loader.create_sample_set(100)
sess = tf.InteractiveSession()
# saver = tf.train.import_meta_graph('saved_analysis_snapshots/snapshots_cifar_complete_from_60_epoch_G_twice/it_2500.ckpt.meta')
# saver.restore(sess, 'saved_analysis_snapshots/snapshots_cifar_complete_from_60_epoch_G_twice/it_2500.ckpt')
train_writer = tf.summary.FileWriter('logs/' + TAG, sess.graph)
if(restore):
snapshot_name = tf.train.latest_checkpoint('logs/' + TAG + '/')
saver = tf.train.import_meta_graph(snapshot_name + '.meta')
print snapshot_name
start_iter = int(snapshot_name.split('-')[-1].split('.')[0]) + 1
print start_iter
saver.restore(sess, snapshot_name)
else:
start_iter = 0
sess.run(tf.global_variables_initializer())
num_train_iter = num_train_epochs * (data_size / (batch_size * num_disc_steps))
Z_sample_all = loader.load_batch_Z(100)
sum_g_loss, num_g_loss = 0, 0
sum_d_loss, num_d_loss = 0, 0
for iteration in range(start_iter, num_train_iter):
for disc_step in range(num_disc_steps):
X_feed = loader.load_batch_X(batch_size)
Z_feed = loader.load_batch_Z(batch_size)
labels_d_real_feed = np.random.choice([0, 1], size=(batch_size,), p=[flip_alpha, 1-flip_alpha])
labels_d_fake_feed = np.ones_like(labels_d_real_feed) - labels_d_real_feed
_, cost_disc, DGZ_ret, DX_ret, disc_merged_ret = sess.run(fetches = [train_op_disc, loss_disc, DGZ, DX, disc_merged], feed_dict = {X:X_feed, Z:Z_feed, labels_d_fake: labels_d_fake_feed, labels_d_real:labels_d_real_feed})
sum_d_loss += cost_disc
num_d_loss += 1
train_writer.add_summary(disc_merged_ret, iteration)
# print ("#%d D #%d\tLossD:%f\tAvgD:%f\tDGZ:%f\tDX:%f" % ((iteration * batch_size * num_disc_steps) / data_size , iteration, cost_disc, sum_d_loss * 1.0 / num_d_loss, np.mean(DGZ_ret), np.mean(DX_ret)))
for gen_step in range(num_gen_steps):
Z_feed = loader.load_batch_Z(batch_size)
_, cost_gen, DGZ_ret, gen_merged_ret = sess.run(fetches = [train_op_gen, loss_gen, DGZ, gen_merged], feed_dict = {Z:Z_feed})
sum_g_loss += cost_gen
num_g_loss += 1
train_writer.add_summary(gen_merged_ret, iteration)
# print ("#%d G #%d\tLossG:%f\tAvgG:%f\tDGZ:%f" % ((iteration * batch_size * num_disc_steps) / data_size, iteration, cost_gen, sum_g_loss * 1.0 / num_g_loss, np.mean(DGZ_ret)))
print ("!%d #%d\tAvgG:%f\tAvgD:%f" % ((iteration * batch_size * num_disc_steps) / data_size, iteration, sum_g_loss * 1.0 / num_g_loss, sum_d_loss * 1.0 / num_d_loss))
if iteration % save_checkpoint_every == 0 and iteration != 0:
# save_name = "snapshots/it_%d.ckpt" % iteration
if not os.path.isdir('logs/' + TAG):
os.makedirs('logs/' + TAG)
save_name = 'logs/' + TAG + '/model.ckpt'
saver.save(sess, save_name, iteration)
print "Snapshot saved to %s" % save_name
if iteration % generate_samples_every == 0:
if not os.path.isdir('analysis/' + TAG):
os.makedirs('analysis/' + TAG)
X_sample_all = loader.load_batch_X(100, update_iterator = False)
im_samples, im_score = sess.run(fetches=[GZ, DGZ], feed_dict={Z:Z_sample_all})
im_samples = d3_scale(im_samples, out_range=(0,255))
# print "evaluation : %d" % evaluate(Xsample_val_set, im_samples)
im_samples = save_sample_images(im_samples, 100)
out = sess.run(im_samples)
if DATASET != 'CELEBA':
out = cv2.cvtColor(out, cv2.COLOR_RGB2BGR)
cv2.imwrite("analysis/"+TAG+"/generator_sample_%d.png" % iteration, out)
cv2.imwrite("analysis/"+TAG+"/generator_latest.png", out)
X_score = sess.run(fetches=[DX], feed_dict={X:X_sample_all})
X_samples = save_sample_images(d3_scale(X_sample_all, out_range=(0,255)), 100)
out = sess.run(X_samples)
if DATASET != 'CELEBA':
out = cv2.cvtColor(out, cv2.COLOR_RGB2BGR)
cv2.imwrite("analysis/"+TAG+"/orig_%d.png" % iteration, out)
cv2.imwrite("analysis/"+TAG+"/orig_latest.png", out)
print "Sample scores: \tDGZ:%f\tDX:%f" % (np.mean(im_score), np.mean(X_score))
train_writer.close()
if __name__ == '__main__':
parser = argparse.ArgumentParser()
parser.add_argument("--dataset", help="dataset name", type=str, choices=['CIFAR10', 'MNIST', 'CELEBA', 'SVHN'], default='MNIST')
parser.add_argument("--num_train_epochs", type=int, help="number of training epochs", default=10)
parser.add_argument("--num_disc_steps", type=int, help="number of discriminator training steps", default=1)
parser.add_argument("--num_gen_steps", type=int, help="number of generator training steps", default=2)
parser.add_argument("--batch_size", type=int, help="batch size", default=64)
parser.add_argument("--save_checkpoint_every", type=int, help="number of iterations after which a checkpoint is saved", default=250)
parser.add_argument("--generate_samples_every", type=int, help="number of iterations after which a sample is generated", default=100)
parser.add_argument("--flip_alpha", type=float, help="probability of flipping the label", default=0.3)
args = parser.parse_args()
main(args.dataset, args.data_size, args.num_train_epochs, args.num_disc_steps, args.num_gen_steps, args.batch_size, args.save_checkpoint_every, args.generate_samples_every, args.flip_alpha)
# define dataset
with tf.name_scope('dataset'):
test_video_clips_tensor = tf.placeholder(shape=[1, height, width, 3 * (num_his + 1)],
dtype=tf.float32)
test_inputs = test_video_clips_tensor[..., 0:num_his*3]
test_gt = test_video_clips_tensor[..., -3:]
print('test inputs = {}'.format(test_inputs))
print('test prediction gt = {}'.format(test_gt))
# define testing generator function and
# in testing, only generator networks, there is no discriminator networks and flownet.
with tf.variable_scope('generator', reuse=None):
print('testing = {}'.format(tf.get_variable_scope().name))
test_outputs = generator(test_inputs, layers=4, output_channel=3)
test_psnr_error,shape = psnr_error(gen_frames=test_outputs, gt_frames=test_gt)
print(shape,[shape])
config = tf.ConfigProto()
config.gpu_options.allow_growth = True
with tf.Session(config=config) as sess:
# dataset
data_loader = DataLoader(test_folder, height, width)
# initialize weights
sess.run(tf.global_variables_initializer())
print('Init global successfully!')
# tf saver
def __init__(self, num_latent, num_out, batch_size, num_disc, num_channels=3,
num_hidden=1024, D_weights=None, G_weights=None, name='GMAN',
mixing='arithmetic', weight_type='normal', objective='original',
boosting_variant=None, self_challenged=False):
self.num_latent = num_latent
self.side = num_out
self.num_channels = num_channels
self.num_hidden = num_hidden
self.batch_size = batch_size
self.N = num_disc
self.base_prob = 0.4
self.delta_p = (0.6 - self.base_prob) / self.N
self.h_adv = num_hidden
self.name = name
self.weight_type = weight_type
self.channel_size = self.batch_size * self.N
self.self_challenged = self_challenged
# boosting variables
self.aux_vars = []
self.aux_vars_new = []
with tf.variable_scope(self.name):
# Define latent distribution
self.z = tf.random_uniform(shape=[self.channel_size, 1, 1, self.num_latent], minval=-1., maxval=1.,
name='z')
# Generate fake images
self.fake = generator(self)
# print(f'self.fake -> {self.fake}')
if boosting_variant is None:
fake_split = tf.split(axis=0, num_or_size_splits=self.N, value=self.fake, name='fake_split')
else:
fake_split = [self.fake] * self.N
# Discriminate fake images
self.Df_logits = [discriminator(self, fake_split[ind], ind, (self.base_prob + self.delta_p * (ind + 1)),
reuse=False)
for ind in range(self.N)]
# Retrieve real images
self.real = tf.placeholder(tf.float32, shape=[self.channel_size, self.side, self.side, self.num_channels],
name='real')
if boosting_variant is None:
real_split = tf.split(axis=0, num_or_size_splits=self.N, value=self.real, name='real_split')
else:
real_split = [self.real] * self.N
# Discriminate real images
self.Dr_logits = [discriminator(self, real_split[ind], ind, (self.base_prob + self.delta_p * (ind + 1)),
reuse=True)
for ind in range(self.N)]
# Retrieve trainable weights
t_vars = tf.trainable_variables()
self.G_vars = [var for var in t_vars if (self.name + '/generator') in var.name]
self.D_vars = [[var for var in t_vars if ('%s/discriminator_%d' % (self.name, num)) in var.name]
for num in range(self.N)]
# Assign values to weights (if given)
self.assign_weights = []
if D_weights is not None:
for i in range(self.N):
for j in range(len(self.D_vars[i])):
self.assign_weights.append(tf.assign(self.D_vars[i][j], D_weights[i][j]))
if G_weights is not None:
for j in range(len(self.G_vars)):
self.assign_weights.append(tf.assign(self.G_vars[j], G_weights[j]))
# Define Discriminator losses
with tf.variable_scope('D_Loss'):
if boosting_variant is None:
self.get_D_losses(obj=objective)
else:
self.get_D_boosted_losses(boosting_variant, obj=objective)
# Define Generator losses
with tf.variable_scope('G_Loss'):
if boosting_variant is None:
self.get_G_loss(mixing, obj=objective)
else:
self.get_G_boosted_loss(boosting_variant, mixing, obj=objective)
# Add Summaries
self.add_summaries()
# Construct Discriminator updates
self.lrd = tf.placeholder(dtype=tf.float32)
self.D_optimizer = tf.train.AdamOptimizer(learning_rate=self.lrd, beta1=0.5)
self.D_optim = [self.D_optimizer.minimize(D_loss, var_list=self.D_vars[ind])
for ind, D_loss in enumerate(self.D_losses)]
# Construct Generator updates
self.lrg = tf.placeholder(dtype=tf.float32)
self.G_optimizer = tf.train.AdamOptimizer(learning_rate=self.lrg, beta1=0.5)
self.G_optim = self.G_optimizer.minimize(self.G_loss, var_list=self.G_vars)
self.G_grads = self.G_optimizer.compute_gradients(self.G_loss, var_list=self.G_vars)
# Join all updates
self.all_opt = [opt for opt in self.D_optim]
self.all_opt.append(self.G_optim)
from models import generator, discriminator, GenNucleiDataset
import torch
G = generator()
D = discriminator()
G = torch.load('./app/weights/G_model.pth', map_location={'cuda:0': 'cpu'})
D = torch.load('./app/weights/D_model.pth', map_location={'cuda:0': 'cpu'})
print(G)
GAN = False
encoder = False
training_steps = 350
generator_model = None
adversarial_model = None
discriminator_model = None
batch_size = 128
if GAN:
for i in range(training_steps):
x = X[i * batch_size:(i + 1) * batch_size, :, :]
size = x.shape[0]
if not discriminator_model:
discriminator_model = discriminator()
if not generator_model:
generator_model = generator()
if not adversarial_model:
adversarial_model = adversarial(
generator_model, discriminator_model)
noise = np.random.uniform(0,
1.0,
size=[batch_size, 100])
fakes = generator_model.predict(noise)
x = np.concatenate((x, fakes))
x = np.expand_dims(x, axis=3)
y = np.zeros([2 * batch_size, 1])
y[:batch_size, :] = 1
d_loss = discriminator_model.train_on_batch(x, y)
y = np.ones([batch_size, 1])
noise = np.random.uniform(0,
lambda_D_gp = 10 lambda_cyc = 10 lambda_mask = 0.1 lambda_mask_smooth = 1e-5 # ============= placeholder ============= real_img = tf.placeholder(tf.float32, [None, 128, 128, 3], name='real_img') real_au = tf.placeholder(tf.float32, [None, 17], name='real_au') desired_au = tf.placeholder(tf.float32, [None, 17], name='desired_au') lr = tf.placeholder(tf.float32, name='lr') # ============= G & D ============= # G(Ic1, c2) * M fake_img, fake_mask = generator(real_img, desired_au, reuse=False) fake_img_masked = fake_mask * real_img + (1 - fake_mask) * fake_img # G(G(Ic1, c2)*M, c1) * M cyc_img, cyc_mask = generator(fake_img_masked, real_au, reuse=True) cyc_img_masked = cyc_mask * fake_img_masked + (1 - cyc_mask) * cyc_img # D(real_I) pred_real_img, pred_real_au = discriminator(real_img, reuse=False) # D(fake_I) pred_fake_img_masked, pred_fake_au = discriminator(fake_img_masked, reuse=True) # ============= losses ============= # G losses loss_g_fake_img_masked = -tf.reduce_mean(pred_fake_img_masked) * lambda_D_img loss_g_fake_au = l2_loss(desired_au, pred_fake_au) * lambda_D_au
epoch = args.epoch
batch_size = args.batch_size
lr = args.lr
gpu_id = args.gpu_id
""" graphs """
with tf.device('/gpu:%d' % gpu_id):
''' graph '''
# nodes
a_real = tf.placeholder(tf.float32, shape=[None, crop_size, crop_size, 3])
b_real = tf.placeholder(tf.float32, shape=[None, crop_size, crop_size, 3])
a2b_sample = tf.placeholder(tf.float32,
shape=[None, crop_size, crop_size, 3])
b2a_sample = tf.placeholder(tf.float32,
shape=[None, crop_size, crop_size, 3])
a2b = models.generator(a_real, 'a2b')
b2a = models.generator(b_real, 'b2a')
b2a2b = models.generator(b2a, 'a2b', reuse=True)
a2b2a = models.generator(a2b, 'b2a', reuse=True)
a_dis = models.discriminator(a_real, 'a')
b2a_dis = models.discriminator(b2a, 'a', reuse=True)
b2a_sample_dis = models.discriminator(b2a_sample, 'a', reuse=True)
b_dis = models.discriminator(b_real, 'b')
a2b_dis = models.discriminator(a2b, 'b', reuse=True)
a2b_sample_dis = models.discriminator(a2b_sample, 'b', reuse=True)
# losses
g_loss_a2b = tf.identity(ops.l2_loss(a2b_dis, tf.ones_like(a2b_dis)),
name='g_loss_a2b')
g_loss_b2a = tf.identity(ops.l2_loss(b2a_dis, tf.ones_like(b2a_dis)),
def generate(args):
# Communicator and Context
extension_module = "cudnn"
ctx = get_extension_context(extension_module, type_config=args.type_config)
nn.set_default_context(ctx)
# Args
latent = args.latent
maps = args.maps
batch_size = args.batch_size
image_size = args.image_size
n_classes = args.n_classes
not_sn = args.not_sn
threshold = args.truncation_threshold
# Model
nn.load_parameters(args.model_load_path)
z = nn.Variable([batch_size, latent])
y_fake = nn.Variable([batch_size])
x_fake = generator(z, y_fake, maps=maps, n_classes=n_classes, test=True, sn=not_sn)\
.apply(persistent=True)
# Generate All
if args.generate_all:
# Monitor
monitor = Monitor(args.monitor_path)
name = "Generated Image Tile All"
monitor_image = MonitorImageTile(name,
monitor,
interval=1,
num_images=args.batch_size,
normalize_method=normalize_method)
# Generate images for all classes
for class_id in range(args.n_classes):
# Generate
z_data = resample(batch_size, latent, threshold)
y_data = generate_one_class(class_id, batch_size)
z.d = z_data
y_fake.d = y_data
x_fake.forward(clear_buffer=True)
monitor_image.add(class_id, x_fake.d)
return
# Generate Indivisually
monitor = Monitor(args.monitor_path)
name = "Generated Image Tile {}".format(
args.class_id) if args.class_id != -1 else "Generated Image Tile"
monitor_image_tile = MonitorImageTile(name,
monitor,
interval=1,
num_images=args.batch_size,
normalize_method=normalize_method)
name = "Generated Image {}".format(
args.class_id) if args.class_id != -1 else "Generated Image"
monitor_image = MonitorImage(name,
monitor,
interval=1,
num_images=args.batch_size,
normalize_method=normalize_method)
z_data = resample(batch_size, latent, threshold)
y_data = generate_random_class(n_classes, batch_size) if args.class_id == -1 else \
generate_one_class(args.class_id, batch_size)
z.d = z_data
y_fake.d = y_data
x_fake.forward(clear_buffer=True)
monitor_image.add(0, x_fake.d)
monitor_image_tile.add(0, x_fake.d)
def train():
graph = tf.Graph()
with graph.as_default():
z = tf.placeholder(tf.float32, shape=[64, 100], name='z')
img_batch = read_records.read_and_decode(
'tf_records/cartoon.tfrecords', batch_size=batch_size)
#generator
# fake=models.generator(z, stddev=0.02, alpha=alpha, name='generator', reuse=False)
#
# #discriminator
# dis_real=models.discriminator(img_batch , alpha=alpha, batch_size=batch_size)
# dis_fake=models.discriminator(fake, alpha=alpha, reuse=True)
#generator
fake = models.generator(z, reuse=False) #, is_training=True
#discriminator
dis_real = models.discriminator(img_batch,
reuse=False) #is_training=True
dis_fake = models.discriminator(fake, reuse=True) #, is_training=True
# #losses
# gene_loss = tf.reduce_mean(tf.squared_difference(dis_fake, 0.9))
# dis_loss = (tf.reduce_mean(tf.squared_difference(dis_real, 0.9))
# + tf.reduce_mean(tf.square(dis_fake))) / 2
gene_loss = tf.reduce_mean(
tf.nn.sigmoid_cross_entropy_with_logits(
labels=tf.ones_like(dis_fake) * 0.9, logits=dis_fake))
d_f_loss = tf.reduce_mean(
tf.nn.sigmoid_cross_entropy_with_logits(
labels=tf.zeros_like(dis_fake), logits=dis_fake))
d_r_loss = tf.reduce_mean(
tf.nn.sigmoid_cross_entropy_with_logits(
labels=tf.ones_like(dis_real) * 0.9, logits=dis_real))
dis_loss = d_f_loss + d_r_loss
gen_loss_sum = tf.summary.scalar("gen_loss", gene_loss)
dis_loss_sum = tf.summary.scalar("dis_loss", dis_loss)
merge_sum_gen = tf.summary.merge([gen_loss_sum])
merge_sum_dis = tf.summary.merge([dis_loss_sum])
#variables
gene_var = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES,
scope='generator')
dis_var = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES,
scope='discriminator')
gene_opt = tf.train.AdamOptimizer(
learning_rate=0.0002, beta1=0.3).minimize(gene_loss,
var_list=gene_var)
dis_opt = tf.train.AdamOptimizer(learning_rate=0.0002,
beta1=0.3).minimize(dis_loss,
var_list=dis_var)
test_sample = models.generator(z, reuse=True) #, is_training=False
test_out = tf.add(test_sample, 0, 'test_out')
init = tf.global_variables_initializer()
print('t')
with tf.Session(graph=graph) as sess:
sess.run(init) # 初始化全局变量
z_ipt_sample = np.random.normal(size=[batch_size, 100])
coord = tf.train.Coordinator()
threads = tf.train.start_queue_runners(coord=coord)
writer = tf.summary.FileWriter('./tensorboard', sess.graph)
saver = tf.train.Saver()
try:
for i in range(run_nums):
z_ipt = np.random.normal(size=[batch_size, 100])
#train D
#_, dis_loss1 = sess.run([dis_opt,dis_loss],feed_dict={real:img_batch,z:z_ipt})
sum_dis, _, dis_loss1 = sess.run(
[merge_sum_dis, dis_opt, dis_loss], feed_dict={z: z_ipt})
#train G
sum_gen, _, gen_loss1 = sess.run(
[merge_sum_gen, gene_opt, gene_loss], feed_dict={z: z_ipt})
if i % 400 == 0:
print(i)
test_sample_opt = sess.run(test_sample,
feed_dict={z: z_ipt_sample})
#print(type(test_sample_opt),test_sample_opt.shape)
utils.mkdir('out_cartoon')
utils.imwrite(utils.immerge(test_sample_opt, 10, 10),
'out_cartoon/' + str(i) + '.jpg')
# writer.add_summary(sum_dis, i)
#writer.add_summary(sum_gen, i)
print("train end!!!")
except tf.errors.OutOfRangeError:
print('out of range')
finally:
coord.request_stop()
coord.request_stop()
coord.join(threads)
writer.close()
saver.save(sess, "./checkpoints/DCGAN")
""" param """
parser = argparse.ArgumentParser(description='')
parser.add_argument('--dataset', dest='dataset', default='horse2zebra', help='which dataset to use')
parser.add_argument('--crop_size', dest='crop_size', type=int, default=256, help='then crop to this size')
args = parser.parse_args()
dataset = args.dataset
crop_size = args.crop_size
""" run """
with tf.Session() as sess:
a_real = tf.placeholder(tf.float32, shape=[None, crop_size, crop_size, 3])
b_real = tf.placeholder(tf.float32, shape=[None, crop_size, crop_size, 3])
a2b = models.generator(a_real, 'a2b')
b2a = models.generator(b_real, 'b2a')
b2a2b = models.generator(b2a, 'a2b', reuse=True)
a2b2a = models.generator(a2b, 'b2a', reuse=True)
# retore
saver = tf.train.Saver()
ckpt_path = utils.load_checkpoint('./checkpoints/' + dataset, sess, saver)
if ckpt_path is None:
raise Exception('No checkpoint!')
else:
print('Copy variables from % s' % ckpt_path)
# test
a_list = glob('./datasets/' + dataset + '/testA/*.jpg')
b_list = glob('./datasets/' + dataset + '/testB/*.jpg')
def run_model(mode,
learning_rate=2e-4,
beta1=0.5,
l1_lambda=100,
max_epochs=200,
summary_freq=200,
display_freq=50,
save_freq=400,
checkpoint_dir="summary/conGAN.ckpt"):
if mode == "train":
xs_train, ys_train = get_input("train")
xs_val, ys_val = get_input("val")
print("load train data successfully")
print("input x shape is {}".format(xs_train.shape))
print("input y shape is {}".format(ys_train.shape))
else:
xs_test, ys_test = get_input("test")
print("load test data successfully")
print("input x shape is {}".format(xs_test.shape))
print("input y shape is {}".format(ys_test.shape))
# build model
# -----------
with tf.name_scope("input"):
x = tf.placeholder(tf.float32, [None, 256, 256, 3], name="x-input")
y_ = tf.placeholder(tf.float32, [None, 256, 256, 3], name="y-input")
G_sample = models.generator(x)
logits_fake = models.con_discriminator(x, G_sample)
logits_real = models.con_discriminator(x, y_)
# get loss
D_loss, G_loss_gan = loss.gan_loss(logits_fake=logits_fake,
logits_real=logits_real)
l1_loss = loss.l1_loss(y_, G_sample)
with tf.variable_scope("G_loss"):
G_loss = G_loss_gan + l1_lambda * l1_loss
tf.summary.scalar("D_loss", D_loss)
tf.summary.scalar("G_loss", G_loss)
merged = tf.summary.merge_all()
# get weights list
D_vars = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES,
"discriminator")
G_vars = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES, "generator")
# get solver
D_solver, G_solver = get_solver(learning_rate=learning_rate, beta1=beta1)
# get training steps
D_train_step = D_solver.minimize(D_loss, var_list=D_vars)
G_train_step = G_solver.minimize(G_loss, var_list=G_vars)
# -----------
# get session
config = tf.ConfigProto()
config.gpu_options.allow_growth = True
sess = tf.InteractiveSession(config=config)
# get saver
saver = tf.train.Saver()
# training phase
if mode == "train":
train_writer = tf.summary.FileWriter("summary/", sess.graph)
# init
sess.run(tf.global_variables_initializer())
# iterations
for step in range(max_epochs * NUM_TRAIN_IMAGES):
if step % NUM_TRAIN_IMAGES == 0:
print("Epoch: {}".format(step / NUM_TRAIN_IMAGES))
mask = np.random.choice(NUM_TRAIN_IMAGES, 1)
_, D_loss_curr = sess.run([D_train_step, D_loss],
feed_dict={
x: xs_train[mask],
y_: ys_train[mask]
})
_, G_loss_curr = sess.run([G_train_step, G_loss],
feed_dict={
x: xs_train[mask],
y_: ys_train[mask]
})
_, G_loss_curr = sess.run([G_train_step, G_loss],
feed_dict={
x: xs_train[mask],
y_: ys_train[mask]
})
if step % display_freq == 0:
print("step {}: D_loss: {}, G_loss: {}".format(
step, D_loss_curr, G_loss_curr))
# save summary and checkpoint
if step % summary_freq == 0:
mask = np.random.choice(NUM_TRAIN_IMAGES, 30)
summary = sess.run(merged,
feed_dict={
x: xs_train[mask],
y_: ys_train[mask]
})
train_writer.add_summary(summary)
saver.save(sess, checkpoint_dir)
# save 5 sample images
if step % save_freq == 0:
samples_train = sess.run(G_sample,
feed_dict={
x: xs_train[0:5],
y_: ys_train[0:5]
})
save_sample_img(samples_train, step=step, mode="train")
samples_val = sess.run(G_sample,
feed_dict={
x: xs_val[0:5],
y_: ys_val[0:5]
})
save_sample_img(samples_val, step=step, mode="val")
# testing phase
if mode == "test":
saver.restore(sess, checkpoint_dir)
for i in range(20):
samples_test = sess.run(G_sample,
feed_dict={
x: xs_test[5 * i:5 * (i + 1)],
y_: ys_test[5 * i:5 * (i + 1)]
})
save_sample_img(samples_test, step=i, mode="test")
# close sess
sess.close()
return 0
def train(args):
# Context
ctx = get_extension_context(args.context,
device_id=args.device_id,
type_config=args.type_config)
nn.set_default_context(ctx)
# Args
latent = args.latent
maps = args.maps
batch_size = args.batch_size
image_size = args.image_size
lambda_ = args.lambda_
# Model
# generator loss
z = nn.Variable([batch_size, latent])
x_fake = generator(z, maps=maps, up=args.up).apply(persistent=True)
p_fake = discriminator(x_fake, maps=maps)
loss_gen = gan_loss(p_fake).apply(persistent=True)
# discriminator loss
p_fake = discriminator(x_fake, maps=maps)
x_real = nn.Variable([batch_size, 3, image_size, image_size])
p_real = discriminator(x_real, maps=maps)
loss_dis = gan_loss(p_fake, p_real).apply(persistent=True)
# gradient penalty
eps = F.rand(shape=[batch_size, 1, 1, 1])
x_rmix = eps * x_real + (1.0 - eps) * x_fake
p_rmix = discriminator(x_rmix, maps=maps)
x_rmix.need_grad = True # Enabling gradient computation for double backward
grads = nn.grad([p_rmix], [x_rmix])
l2norms = [F.sum(g**2.0, [1, 2, 3])**0.5 for g in grads]
gp = sum([F.mean((l - 1.0)**2.0) for l in l2norms])
loss_dis += lambda_ * gp
# generator with fixed value for test
z_test = nn.Variable.from_numpy_array(np.random.randn(batch_size, latent))
x_test = generator(z_test, maps=maps, test=True,
up=args.up).apply(persistent=True)
# Solver
solver_gen = S.Adam(args.lrg, args.beta1, args.beta2)
solver_dis = S.Adam(args.lrd, args.beta1, args.beta2)
with nn.parameter_scope("generator"):
params_gen = nn.get_parameters()
solver_gen.set_parameters(params_gen)
with nn.parameter_scope("discriminator"):
params_dis = nn.get_parameters()
solver_dis.set_parameters(params_dis)
# Monitor
monitor = Monitor(args.monitor_path)
monitor_loss_gen = MonitorSeries("Generator Loss", monitor, interval=10)
monitor_loss_cri = MonitorSeries("Negative Critic Loss",
monitor,
interval=10)
monitor_time = MonitorTimeElapsed("Training Time", monitor, interval=10)
monitor_image_tile_train = MonitorImageTile("Image Tile Train",
monitor,
num_images=batch_size,
interval=1,
normalize_method=denormalize)
monitor_image_tile_test = MonitorImageTile("Image Tile Test",
monitor,
num_images=batch_size,
interval=1,
normalize_method=denormalize)
# Data Iterator
di = data_iterator_cifar10(batch_size, True)
# Train loop
for i in range(args.max_iter):
# Train discriminator
x_fake.need_grad = False # no need backward to generator
for _ in range(args.n_critic):
solver_dis.zero_grad()
x_real.d = di.next()[0] / 127.5 - 1.0
z.d = np.random.randn(batch_size, latent)
loss_dis.forward(clear_no_need_grad=True)
loss_dis.backward(clear_buffer=True)
solver_dis.update()
# Train generator
x_fake.need_grad = True # need backward to generator
solver_gen.zero_grad()
z.d = np.random.randn(batch_size, latent)
loss_gen.forward(clear_no_need_grad=True)
loss_gen.backward(clear_buffer=True)
solver_gen.update()
# Monitor
monitor_loss_gen.add(i, loss_gen.d)
monitor_loss_cri.add(i, -loss_dis.d)
monitor_time.add(i)
# Save
if i % args.save_interval == 0:
monitor_image_tile_train.add(i, x_fake)
monitor_image_tile_test.add(i, x_test)
nn.save_parameters(
os.path.join(args.monitor_path, "params_{}.h5".format(i)))
# Last
x_test.forward(clear_buffer=True)
nn.save_parameters(
os.path.join(args.monitor_path, "params_{}.h5".format(i)))
monitor_image_tile_train.add(i, x_fake)
monitor_image_tile_test.add(i, x_test)
import os
import numpy as np
import tensorflow as tf
import models
num_samples = 100
batch_size = 64
output_dir = 'output'
checkpoint_dir = os.path.join(output_dir, 'checkpoints', 'checkpoint_4.ckpt')
z = tf.placeholder(tf.float32, shape=(None, 1, 1, 100))
isTrain = tf.placeholder(dtype=tf.bool)
fake_x = models.generator(z, isTrain)
samples = np.random.rand(num_samples, 64, 64, 1)
saver = tf.train.Saver()
print('start')
with tf.Session() as sess:
saver.restore(sess, checkpoint_dir)
for i in range(int(num_samples / batch_size)):
noise = np.random.normal(0, 1, (batch_size, 1, 1, 100))
samples = sess.run(fake_x, feed_dict = {z: noise, isTrain: False})
with open(os.path.join(output_dir, 'samples', 'samples!.txt'), 'a') as f:
