def search(sess, tensor, labels_one_hot, decay_steps, save_tensor=False):
fz = tf.Variable(tensor, tf.float32)
fz.initializer.run(session=sess)
fz = tf.expand_dims(fz, 0)
fz = tf.cast(fz, tf.float32)
zp = tf.Variable(np.random.normal(size=(1, Z_NOISE_DIM)), dtype=tf.float32)
zp.initializer.run(session=sess)
fzp = sampler(zp, labels_one_hot, 1)
loss = tf.losses.mean_squared_error(labels=fz, predictions=fzp)
# Decayed gradient descent
descent_step = tf.Variable(0, trainable=False)
descent_step.initializer.run(session=sess)
starter_learning_rate = 0.99
learning_rate = tf.train.exponential_decay(starter_learning_rate,
descent_step, decay_steps, 0.05)
opt = tf.train.GradientDescentOptimizer(learning_rate)
# Optimize on the variable zp
train = opt.minimize(loss, var_list=zp, global_step=descent_step)
for i in range(decay_steps):
_, loss_value, zp_val, eta = sess.run((train, loss, zp, learning_rate))
print("%03d) eta=%03f, loss = %f" % (i, eta, loss_value))
zp_val = sess.run(zp)
return zp, zp_val
def save_mosaic_output(sess,
z_batch_tensor,
input_z,
input_g_y,
labels,
steps,
save_tensor=False):
"""
This function does blah blah.
"""
example_z = sess.run(z_batch_tensor)
samples = sess.run(sampler(input_z, input_g_y),
feed_dict={
input_z: example_z,
input_g_y: labels
})
imgs = [img[:, :, :] for img in samples]
figure_side = int(np.sqrt(BATCH_SIZE))
fig, ax = plt.subplots(nrows=figure_side, ncols=figure_side)
k = 0
for i in range(figure_side):
for j in range(figure_side):
ax[i, j].imshow(
transform_image(image_from_array(imgs[k])).astype(np.uint8))
ax[i, j].axis('off')
k = k + 1
fig.subplots_adjust(hspace=0.01, wspace=0.01)
if not os.path.exists(FULL_OUTPUT_PATH):
os.mkdir(FULL_OUTPUT_PATH)
fig.savefig(FULL_OUTPUT_PATH + str(steps) + '_mosaic.png')
plt.close('all')
def generate_samples(sess,
z_batch_tensor,
input_z,
input_g_y,
labels,
num_samples,
save_tensor=False,
name_prefix="output"):
"""
This function does blah blah.
"""
num_batches = (num_samples // BATCH_SIZE) + 1
for batch_count in range(num_batches):
example_z = sess.run(z_batch_tensor)
samples = sess.run(sampler(input_z, input_g_y),
feed_dict={
input_z: example_z,
input_g_y: labels
})
imgs = [img[:, :, :] for img in samples]
save_images(imgs, labels, batch_count, name_prefix=name_prefix)
if save_tensor:
save_tensors(example_z,
labels,
batch_count,
name_prefix=name_prefix)
def search_image(sess, image_to_search, decay_steps):
image_arr = (np.array(image_to_search) / 127.5) - 1
labels = np.random.randint(0, 1, 1)
labels_one_hot = tf.one_hot(labels, Y_DIM, 1.0, 0.0)
zp, zp_value = search(sess, image_arr, labels_one_hot, decay_steps)
samples = sess.run(sampler(zp, labels_one_hot, 1))
imgs = [img[:, :, :] for img in samples]
img = Image.fromarray(
((np.reshape(imgs[0],
(DIM_X, DIM_Y, DIM_Z)) + 1) * 127.5).astype(np.uint8))
return img, zp_value
def interpolate(sess, tensor_a, tensor_b, labels, steps=50, prefix=None):
z = np.empty(shape=(steps, Z_NOISE_DIM))
for i, alpha in enumerate(np.linspace(start=0.0, stop=1.0, num=steps)):
z[i] = (1 - alpha) * tensor_a + alpha * tensor_b
z_ = tf.placeholder(tf.float32, [steps, Z_NOISE_DIM])
g_labels = tf.placeholder(tf.float32, [None, Y_DIM])
labels = [labels[0]] * int(steps / 2) + [labels[1]] * int(steps / 2)
labels = np.eye(2)[labels]
samples = sess.run(sampler(z_, g_labels, steps),
feed_dict={
z_: z,
g_labels: labels
})
imgs = [img[:, :, :] for img in samples]
for i, image in enumerate(imgs):
filepath = FULL_OUTPUT_PATH + 'interp_'
if prefix is not None:
filepath += prefix
filepath += str(i) + '.png'
output_image = Image.fromarray(
transform_image(image_from_array(image)).astype(np.uint8))
output_image.save(filepath)
def save_output(sess,
z_batch_tensor,
input_z,
input_g_y,
labels,
steps,
num_samples=1,
save_tensor=False):
"""
This function does blah blah.
"""
example_z = sess.run(z_batch_tensor)
samples = sess.run(sampler(input_z, input_g_y),
feed_dict={
input_z: example_z,
input_g_y: labels
})
imgs = [img[:, :, :] for img in samples]
if num_samples > BATCH_SIZE:
num_samples = BATCH_SIZE
save_images(imgs, labels, num_samples, stepcount=steps)
if save_tensor:
save_tensors(example_z)