def evaluate(hparams, run_eval_loop=True):
"""Runs an evaluation loop.
Args:
hparams: An HParams instance containing the eval hyperparameters.
run_eval_loop: Whether to run the full eval loop. Set to False for testing.
"""
# Fetch and generate images to run through Inception.
with tf.name_scope('inputs'):
real_data, _ = data_provider.provide_data('test',
hparams.num_images_generated,
shuffle=False)
generated_data = _get_generated_data(hparams.num_images_generated)
# Compute Frechet Inception Distance.
if hparams.eval_frechet_inception_distance:
fid = util.get_frechet_inception_distance(real_data, generated_data,
hparams.num_images_generated,
hparams.num_inception_images)
tf.summary.scalar('frechet_inception_distance', fid)
# Compute normal Inception scores.
if hparams.eval_real_images:
inc_score = util.get_inception_scores(real_data,
hparams.num_images_generated,
hparams.num_inception_images)
else:
inc_score = util.get_inception_scores(generated_data,
hparams.num_images_generated,
hparams.num_inception_images)
tf.summary.scalar('inception_score', inc_score)
# Create ops that write images to disk.
image_write_ops = None
if hparams.num_images_generated >= 100 and hparams.write_to_disk:
reshaped_imgs = tfgan.eval.image_reshaper(generated_data[:100],
num_cols=10)
uint8_images = data_provider.float_image_to_uint8(reshaped_imgs)
image_write_ops = tf.io.write_file(
'%s/%s' % (hparams.eval_dir, 'unconditional_cifar10.png'),
tf.image.encode_png(uint8_images[0]))
# For unit testing, use `run_eval_loop=False`.
if not run_eval_loop: return
evaluation.evaluate_repeatedly(
hparams.checkpoint_dir,
master=hparams.master,
hooks=[
evaluation.SummaryAtEndHook(hparams.eval_dir),
evaluation.StopAfterNEvalsHook(1)
],
eval_ops=image_write_ops,
max_number_of_evaluations=hparams.max_number_of_evaluations)
def test_provide_data_can_be_reinitialized(self, mock_tfds):
"""Test that the iterator created in `provide_data` can be reused."""
batch_size = 5
mock_tfds.load.return_value = self.mock_ds
images, labels = data_provider.provide_data('test', batch_size)
with self.session() as sess:
sess.run([images, labels])
sess.run([images, labels])
with self.session() as sess:
sess.run([images, labels])
sess.run([images, labels])
def test_provide_data(self, mock_tfds, one_hot):
batch_size = 5
mock_tfds.load.return_value = self.mock_ds
images, labels = data_provider.provide_data(
'test', batch_size, one_hot=one_hot)
with self.cached_session() as sess:
images, labels = sess.run([images, labels])
self.assertTupleEqual(images.shape, (batch_size, 32, 32, 3))
self.assertTrue(np.all(np.abs(images) <= 1))
if one_hot:
expected_lbls_shape = (batch_size, 10)
else:
expected_lbls_shape = (batch_size,)
self.assertTupleEqual(labels.shape, expected_lbls_shape)
def train(hparams):
"""Trains a CIFAR10 GAN.
Args:
hparams: An HParams instance containing the hyperparameters for training.
"""
if not tf.io.gfile.exists(hparams.train_log_dir):
tf.io.gfile.makedirs(hparams.train_log_dir)
with tf.device(
tf.compat.v1.train.replica_device_setter(hparams.ps_replicas)):
# Force all input processing onto CPU in order to reserve the GPU for
# the forward inference and back-propagation.
with tf.compat.v1.name_scope('inputs'):
with tf.device('/cpu:0'):
images, _ = data_provider.provide_data('train',
hparams.batch_size,
num_parallel_calls=4)
# Define the GANModel tuple.
generator_fn = networks.generator
discriminator_fn = networks.discriminator
generator_inputs = tf.random.normal([hparams.batch_size, 64])
gan_model = tfgan.gan_model(generator_fn,
discriminator_fn,
real_data=images,
generator_inputs=generator_inputs)
tfgan.eval.add_gan_model_image_summaries(gan_model)
# Get the GANLoss tuple. Use the selected GAN loss functions.
with tf.compat.v1.name_scope('loss'):
gan_loss = tfgan.gan_loss(gan_model,
gradient_penalty_weight=1.0,
add_summaries=True)
# Get the GANTrain ops using the custom optimizers and optional
# discriminator weight clipping.
with tf.compat.v1.name_scope('train'):
gen_opt, dis_opt = _get_optimizers(hparams)
train_ops = tfgan.gan_train_ops(gan_model,
gan_loss,
generator_optimizer=gen_opt,
discriminator_optimizer=dis_opt,
summarize_gradients=True)
# Run the alternating training loop. Skip it if no steps should be taken
# (used for graph construction tests).
status_message = tf.strings.join([
'Starting train step: ',
tf.as_string(tf.compat.v1.train.get_or_create_global_step())
],
name='status_message')
if hparams.max_number_of_steps == 0:
return
tfgan.gan_train(train_ops,
hooks=([
tf.estimator.StopAtStepHook(
num_steps=hparams.max_number_of_steps),
tf.estimator.LoggingTensorHook([status_message],
every_n_iter=10)
]),
logdir=hparams.train_log_dir,
master=hparams.master,
is_chief=hparams.task == 0)