From f349edd5f587e6fd5a2e4195dc5f9bf7d09827fc Mon Sep 17 00:00:00 2001 From: supertramp2 Date: Thu, 19 Aug 2021 01:17:27 +0530 Subject: [PATCH 01/20] add esrgan example --- tensorflow_gan/examples/esrgan/README.md | 17 ++ .../examples/esrgan/data_provider.py | 84 ++++++ .../examples/esrgan/data_provider_test.py | 56 ++++ tensorflow_gan/examples/esrgan/eval.py | 57 ++++ tensorflow_gan/examples/esrgan/eval_lib.py | 77 +++++ tensorflow_gan/examples/esrgan/eval_test.py | 57 ++++ tensorflow_gan/examples/esrgan/losses.py | 120 ++++++++ tensorflow_gan/examples/esrgan/losses_test.py | 60 ++++ tensorflow_gan/examples/esrgan/networks.py | 163 +++++++++++ .../examples/esrgan/networks_test.py | 66 +++++ tensorflow_gan/examples/esrgan/train.py | 82 ++++++ tensorflow_gan/examples/esrgan/train_lib.py | 275 ++++++++++++++++++ tensorflow_gan/examples/esrgan/train_test.py | 69 +++++ tensorflow_gan/examples/esrgan/utils.py | 186 ++++++++++++ tensorflow_gan/examples/esrgan/utils_test.py | 79 +++++ 15 files changed, 1448 insertions(+) create mode 100644 tensorflow_gan/examples/esrgan/README.md create mode 100644 tensorflow_gan/examples/esrgan/data_provider.py create mode 100644 tensorflow_gan/examples/esrgan/data_provider_test.py create mode 100644 tensorflow_gan/examples/esrgan/eval.py create mode 100644 tensorflow_gan/examples/esrgan/eval_lib.py create mode 100644 tensorflow_gan/examples/esrgan/eval_test.py create mode 100644 tensorflow_gan/examples/esrgan/losses.py create mode 100644 tensorflow_gan/examples/esrgan/losses_test.py create mode 100644 tensorflow_gan/examples/esrgan/networks.py create mode 100644 tensorflow_gan/examples/esrgan/networks_test.py create mode 100644 tensorflow_gan/examples/esrgan/train.py create mode 100644 tensorflow_gan/examples/esrgan/train_lib.py create mode 100644 tensorflow_gan/examples/esrgan/train_test.py create mode 100644 tensorflow_gan/examples/esrgan/utils.py create mode 100644 tensorflow_gan/examples/esrgan/utils_test.py diff --git a/tensorflow_gan/examples/esrgan/README.md b/tensorflow_gan/examples/esrgan/README.md new file mode 100644 index 0000000..7d215c3 --- /dev/null +++ b/tensorflow_gan/examples/esrgan/README.md @@ -0,0 +1,17 @@ +## ESRGAN + +### How to run +1. Run the setup instructions in [tensorflow_gan/examples/README.md](https://github.com/tensorflow/gan/blob/master/tensorflow_gan/examples/README.md#steps-to-run-an-example) +2. Run: +``` +python esrgan/train.py +``` + +The Notebook files for training ESRGAN on Google Colaboratory can be found [here](colab_notebooks) + +### Description +The ESRGAN model proposed in the paper [ESRGAN: Enhanced Super-Resolution Generative Adversarial Networks (Wang Xintao et al.)](https://arxiv.org/abs/1809.00219) performs the task of image super-resolution which is the process of reconstructing high resolution (HR) image from a given low resolution (LR) image. Here we have trained the ESRGAN model on the DIV2K dataset and the model is evaluated using TF-GAN. + +### Results + + diff --git a/tensorflow_gan/examples/esrgan/data_provider.py b/tensorflow_gan/examples/esrgan/data_provider.py new file mode 100644 index 0000000..f35d70c --- /dev/null +++ b/tensorflow_gan/examples/esrgan/data_provider.py @@ -0,0 +1,84 @@ +# coding=utf-8 +# Copyright 2021 The TensorFlow GAN Authors. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import os +import tensorflow as tf +import tensorflow_datasets as tfds +from tensorflow.python.data.experimental import AUTOTUNE + + +def random_flip(lr_img, hr_img): + """ Randomly flips LR and HR images for data augmentation.""" + rn = tf.random.uniform(shape=(), maxval=1) + + return tf.cond(rn < 0.5, + lambda: (lr_img, hr_img), + lambda: (tf.image.flip_left_right(lr_img), + tf.image.flip_left_right(hr_img))) + +def random_rotate(lr_img, hr_img): + """ Randomly rotates LR and HR images for data augmentation.""" + rn = tf.random.uniform(shape=(), maxval=4, dtype=tf.int32) + return tf.image.rot90(lr_img, rn), tf.image.rot90(hr_img, rn) + + +def get_div2k_data(HParams, + mode='train', + shuffle=True, + repeat_count=None): + """ Downloads and loads DIV2K dataset. + Args: + HParams : For getting values for different parameters. + mode : Either 'train' or 'valid'. + shuffle : Whether to shuffle the images in the dataset. + repeat_count : Repetition of data during training. + Returns: + A tf.data.Dataset with pairs of LR image and HR image tensors. + + Raises: + TypeError : If the data directory(data_dir) is not specified. + """ + bs = HParams.batch_size + split = 'train' if mode == 'train' else 'validation' + + def scale(image, *args): + hr_size = HParams.hr_dimension + scale = HParams.scale + + hr_image = image + hr_image = tf.image.resize(hr_image, [hr_size, hr_size]) + lr_image = tf.image.resize(hr_image, [hr_size//scale, hr_size//scale], method='bicubic') + + hr_image = tf.clip_by_value(hr_image, 0, 255) + lr_image = tf.clip_by_value(lr_image, 0, 255) + + return lr_image, hr_image + + dataset = (tfds.load('div2k/bicubic_x4', + split=split, + data_dir=HParams.data_dir, + as_supervised=True) + .map(scale, num_parallel_calls=4) + .cache()) + + if shuffle: + dataset = dataset.shuffle( + buffer_size=10000, reshuffle_each_iteration=True) + + dataset = dataset.batch(HParams.batch_size) + dataset = dataset.repeat(repeat_count) + dataset = dataset.prefetch(buffer_size=AUTOTUNE) + + return dataset diff --git a/tensorflow_gan/examples/esrgan/data_provider_test.py b/tensorflow_gan/examples/esrgan/data_provider_test.py new file mode 100644 index 0000000..1b4b067 --- /dev/null +++ b/tensorflow_gan/examples/esrgan/data_provider_test.py @@ -0,0 +1,56 @@ +# coding=utf-8 +# Copyright 2021 The TensorFlow GAN Authors. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Tests for tfgan.examples.esrgan.data_provider""" + +from __future__ import absolute_import +from __future__ import division +from __future__ import print_function + +from absl.testing import absltest +import numpy as np +import tensorflow as tf +import data_provider +import collections + +Params = collections.namedtuple('HParams', ['hr_dimension', + 'scale', + 'batch_size', + 'data_dir']) + +class DataProviderTest(tf.test.TestCase, absltest.TestCase): + + def setUp(self): + super(DataProviderTest, self).setUp() + self.HParams = Params(256, 4, 32, '/content/') + self.dataset = data_provider.get_div2k_data(self.HParams) + self.mock_lr = tf.random.normal([32, 64, 64, 3]) + self.mock_hr = tf.random.normal([32, 256, 256, 3]) + + def test_dataset(self): + with self.cached_session() as sess: + self.assertIsInstance(self.dataset, tf.data.Dataset) + lr_image, hr_image = next(iter(self.dataset)) + sess.run(tf.compat.v1.global_variables_initializer()) + + self.assertEqual(type(self.mock_lr), type(lr_image)) + self.assertEqual(self.mock_lr.shape, lr_image.shape) + + self.assertEqual(type(self.mock_hr), type(hr_image)) + self.assertEqual(self.mock_hr.shape, hr_image.shape) + + +if __name__ == '__main__': + tf.test.main() diff --git a/tensorflow_gan/examples/esrgan/eval.py b/tensorflow_gan/examples/esrgan/eval.py new file mode 100644 index 0000000..b448552 --- /dev/null +++ b/tensorflow_gan/examples/esrgan/eval.py @@ -0,0 +1,57 @@ +# coding=utf-8 +# Copyright 2021 The TensorFlow GAN Authors. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from absl import flags, logging, app +import tensorflow as tf +import eval_lib +import data_provider + + +flags.DEFINE_integer('batch_size', 2, + 'The number of images in each batch.') +flags.DEFINE_integer('hr_dimension', 128, + 'Dimension of a HR image.') +flags.DEFINE_integer('scale', 4, + 'Factor by which LR images are downscaled.') +flags.DEFINE_string('model_dir', '/content/', + 'Directory where the trained models are stored.') +flags.DEFINE_string('data_dir', '/content/datasets', + 'Directory where dataset is stored.') +flags.DEFINE_integer('num_steps', 2, + 'The number of steps for evaluation.') +flags.DEFINE_integer('num_inception_images', 2, + 'The number of images passed for evaluation at each step.') +flags.DEFINE_string('image_dir', '/content/results', + 'Directory to save generated images during evaluation.') +flags.DEFINE_boolean('eval_real_images', False, + 'Whether Phase 1 training is done or not') + +FLAGS = flags.FLAGS + +def main(_): + hparams = eval_lib.HParams(FLAGS.batch_size, FLAGS.hr_dimension, + FLAGS.scale, FLAGS.model_dir, + FLAGS.data_dir,FLAGS.num_steps, + FLAGS.num_inception_images,FLAGS.image_dir, + FLAGS.eval_real_images) + + generator = tf.keras.models.load_model(FLAGS.model_dir + + 'Phase_2/interpolated_generator') + data = data_provider.get_div2k_data(hparams, mode='valid') + eval_lib.evaluate(hparams, generator, data) + +if __name__ == '__main__': + logging.set_verbosity(logging.INFO) + app.run(main) \ No newline at end of file diff --git a/tensorflow_gan/examples/esrgan/eval_lib.py b/tensorflow_gan/examples/esrgan/eval_lib.py new file mode 100644 index 0000000..da28238 --- /dev/null +++ b/tensorflow_gan/examples/esrgan/eval_lib.py @@ -0,0 +1,77 @@ +# coding=utf-8 +# Copyright 2021 The TensorFlow GAN Authors. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import tensorflow as tf +from absl import logging +import utils +import collections + +HParams = collections.namedtuple('HParams', [ + 'batch_size', 'hr_dimension', + 'scale', + 'model_dir', 'data_dir', + 'num_steps', 'num_inception_images', + 'image_dir', 'eval_real_images']) + +def evaluate(hparams, generator, data): + """ Runs an evaluation loop and calculates the mean FID, + Inception and PSNR scores observed on the validation dataset. + + Args: + hparams: Parameters for evaluation. + generator : The trained generator network. + data : Validation DIV2K dataset. + """ + fid_metric = tf.keras.metrics.Mean() + inc_metric = tf.keras.metrics.Mean() + psnr_metric = tf.keras.metrics.Mean() + step = 0 + for lr, hr in data.take(hparams.num_steps): + step += 1 + # Generate fake images for evaluating the model + gen = generator(lr) + + if step % hparams.num_steps//10: + utils.visualize_results(lr, + gen, + hr, + image_dir=hparams.image_dir, + step=step) + + # Compute Frechet Inception Distance. + fid_score = utils.get_frechet_inception_distance( + hr, gen, + hparams.batch_size, + hparams.num_inception_images) + + fid_metric(fid_score) + + # Compute Inception Scores. + if hparams.eval_real_images: + inc_score = utils.get_inception_scores(hr, + hparams.batch_size, + hparams.num_inception_images) + else: + inc_score = utils.get_inception_scores(gen, + hparams.batch_size, + hparams.num_inception_images) + inc_metric(inc_score) + + # Compute PSNR values. + psnr = utils.get_psnr(hr, gen) + psnr_metric(psnr) + + logging.info('FID Score :{}\tInception Score :{}\tPSNR value :{}'.format( + fid_metric.result(), inc_metric.result(), psnr_metric.result())) \ No newline at end of file diff --git a/tensorflow_gan/examples/esrgan/eval_test.py b/tensorflow_gan/examples/esrgan/eval_test.py new file mode 100644 index 0000000..62a9a33 --- /dev/null +++ b/tensorflow_gan/examples/esrgan/eval_test.py @@ -0,0 +1,57 @@ +# coding=utf-8 +# Copyright 2021 The TensorFlow GAN Authors. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Tests for tfgan.examples.esrgan.eval""" + +from __future__ import absolute_import +from __future__ import division +from __future__ import print_function + +from absl.testing import absltest +import os +import collections + +import tensorflow as tf +import eval_lib, networks + +HParams = collections.namedtuple('HParams', [ + 'num_steps', 'image_dir', 'batch_size', 'num_inception_images', + 'eval_real_images', 'hr_dimension', 'scale', 'trunk_size']) + +class EvalTest(tf.test.TestCase): + def setUp(self): + self.HParams = HParams(1, '/content/', + 2, 2, + True, 256, + 4, 11) + + d = tf.data.Dataset.from_tensor_slices(tf.random.normal([2, 256, 256, 3])) + def lr(hr): + lr = tf.image.resize(hr, [64, 64], method='bicubic') + return lr, hr + + d = d.map(lr) + d = d.batch(2) + self.mock_dataset = d + self.generator = networks.generator_network(self.HParams) + + def test_eval(self): + self.assertIsNone(eval_lib.evaluate(self.HParams, + self.generator, + self.mock_dataset)) + +if __name__ == '__main__': + tf.test.main() + diff --git a/tensorflow_gan/examples/esrgan/losses.py b/tensorflow_gan/examples/esrgan/losses.py new file mode 100644 index 0000000..92a5487 --- /dev/null +++ b/tensorflow_gan/examples/esrgan/losses.py @@ -0,0 +1,120 @@ +# coding=utf-8 +# Copyright 2021 The TensorFlow GAN Authors. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import os +import tensorflow as tf + +def pixel_loss(y_true, y_pred): + """ To calculate the L1 Loss. + Args : + y_true : Original HR image present in the dataset. + y_pred : Image generated by the generator network. + Returns : + Mean absolute difference between the two images. + """ + y_true = tf.cast(y_true, tf.float32) + y_pred = tf.cast(y_pred, tf.float32) + return tf.reduce_mean(tf.reduce_mean(tf.abs(y_true - y_pred), axis=0)) + + +def ragan_generator_loss(d_real, + d_fake, + scope=None): + """ To calculate the adversarial loss for generator + network using a relativistic discriminator. + + Args: + d_real: Discriminator output on real data. + d_fake: Discriminator output on generated data. Expected + to be in the range of (-inf, inf). + scope: The scope for the operations performed in computing the loss. + Returns: + Adversarial loss for generator. + """ + with tf.compat.v1.name_scope( + scope, + 'relativistic_avg_generator_loss', + values=[d_real, d_fake]): + def get_logits(x, y): + return x - tf.reduce_mean(y) + + real_logits = get_logits(d_real, d_fake) + fake_logits = get_logits(d_fake, d_real) + + real_loss = tf.reduce_mean(tf.nn.sigmoid_cross_entropy_with_logits( + labels=tf.zeros_like(real_logits), logits=real_logits)) + fake_loss = tf.reduce_mean(tf.nn.sigmoid_cross_entropy_with_logits( + labels=tf.ones_like(fake_logits), logits=fake_logits)) + + return real_loss + fake_loss + + +def ragan_discriminator_loss(d_real, + d_fake, + scope=None): + """ To calculate the adversarial loss for discriminator + network using a relativistic discriminator. + + Args: + d_real: Discriminator output on real data. + d_fake: Discriminator output on generated data. Expected + to be in the range of (-inf, inf). + scope: The scope for the operations performed in computing the loss. + Returns: + Adversarial loss for discriminator. + """ + with tf.compat.v1.name_scope( + scope, + 'relativistic_avg_discriminator_loss', + values=[d_real, d_fake]): + def get_logits(x, y): + return x - tf.reduce_mean(y) + + real_logits = get_logits(d_real, d_fake) + fake_logits = get_logits(d_fake, d_real) + + real_loss = tf.reduce_mean(tf.nn.sigmoid_cross_entropy_with_logits( + labels=tf.ones_like(real_logits), logits=real_logits)) + fake_loss = tf.reduce_mean(tf.nn.sigmoid_cross_entropy_with_logits( + labels=tf.zeros_like(fake_logits), logits=fake_logits)) + + return real_loss + fake_loss + +def vgg_loss(weight=None, input_shape=None): + """ Perceptual Loss calculation using pre-trained VGG19 + model before activation as mentioned in the paper. + Args: + weights: Weights to be loaded. + input_shape: Shape of input image. + + Returns : + Perceptual loss + """ + vgg_model = tf.keras.applications.vgg19.VGG19( + input_shape=input_shape, weights=weight, include_top=False + ) + + for layer in vgg_model.layers: + layer.trainable = False + + vgg_model.get_layer("block5_conv4").activation = lambda x: x + vgg = tf.keras.Model( + inputs=[vgg_model.input], + outputs=[vgg_model.get_layer("block5_conv4").output]) + + def loss(y_true, y_pred): + return tf.compat.v1.losses.absolute_difference(vgg(y_true), vgg(y_pred)) + + return loss diff --git a/tensorflow_gan/examples/esrgan/losses_test.py b/tensorflow_gan/examples/esrgan/losses_test.py new file mode 100644 index 0000000..588fa82 --- /dev/null +++ b/tensorflow_gan/examples/esrgan/losses_test.py @@ -0,0 +1,60 @@ +# coding=utf-8 +# Copyright 2021 The TensorFlow GAN Authors. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Tests for tfgan.examples.esrgan.losses""" + +from __future__ import absolute_import +from __future__ import division +from __future__ import print_function + +from absl.testing import absltest +import os + +import tensorflow as tf +import losses + +class LossesTest(tf.test.TestCase, absltest.TestCase): + def setUp(self): + super(LossesTest, self).setUp() + self.real_data = tf.constant([[3.1, 2.3, -12.3, 32.1]]) + self.generated_data = tf.constant([[-12.3, 23.2, 16.3, -43.2]]) + + self._discriminator_gen_logits = tf.constant([10.0, 4.4, -5.5, 3.6]) + self._discriminator_real_logits = tf.constant([-2.0, 0.4, 12.5, 2.7]) + + self._expected_pixel_loss = 35.050003 + self._expected_g_loss = 4.9401135 + self._expected_d_loss = 4.390114 + + def test_pixel_loss(self): + pixel_loss = losses.pixel_loss(self.real_data, + self.generated_data) + with self.cached_session() as sess: + sess.run(tf.compat.v1.global_variables_initializer()) + self.assertNear(self._expected_pixel_loss, + sess.run(pixel_loss), 1e-5) + + def test_ragan_loss(self): + g_loss = losses.ragan_generator_loss(self._discriminator_real_logits, + self._discriminator_gen_logits) + d_loss = losses.ragan_discriminator_loss(self._discriminator_real_logits, + self._discriminator_gen_logits) + with self.cached_session() as sess: + sess.run(tf.compat.v1.global_variables_initializer()) + self.assertNear(self._expected_g_loss, sess.run(g_loss), 1e-5) + self.assertNear(self._expected_d_loss, sess.run(d_loss), 1e-5) + +if __name__ == '__main__': + tf.test.main() diff --git a/tensorflow_gan/examples/esrgan/networks.py b/tensorflow_gan/examples/esrgan/networks.py new file mode 100644 index 0000000..c30d87d --- /dev/null +++ b/tensorflow_gan/examples/esrgan/networks.py @@ -0,0 +1,163 @@ +# coding=utf-8 +# Copyright 2021 The TensorFlow GAN Authors. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import os +import tensorflow as tf +from keras.models import Model +from keras.layers import Input, Add, Concatenate +from keras.layers import BatchNormalization, LeakyReLU, Conv2D, Dense, Conv2DTranspose +from keras.layers import Lambda, Dropout, Flatten + + +""" +Implementation of Generator (ESRGAN_G) and Discriminator (ESRGAN_D) models +based on the architecture proposed in the paper +'ESRGAN: Enhanced Super-Resolution Generative Adversarial Networks'. +""" + +def _conv_block(input, filters=32, activation=True): + h = Conv2D(filters, kernel_size=[3,3], bias_initializer="zeros", + strides=[1,1], padding='same')(input) + if activation: + h = LeakyReLU(0.2)(h) + return h + +def _conv_block_d(input, out_channel): + x = Conv2D(out_channel, 3,1, padding='same', use_bias=False)(input) + x = BatchNormalization(momentum=0.8)(x) + x = LeakyReLU(alpha=0.2)(x) + + x = Conv2D(out_channel, 4,2, padding='same', use_bias=False)(x) + x = BatchNormalization(momentum=0.8)(x) + x = LeakyReLU(alpha=0.2)(x) + return x + +def dense_block(input): + h1 = _conv_block(input) + h1 = Concatenate()([input, h1]) + + h2 = _conv_block(h1) + h2 = Concatenate()([input, h1, h2]) + + h3 = _conv_block(h2) + h3 = Concatenate()([input, h1, h2, h3]) + + h4 = _conv_block(h3) + h4 = Concatenate()([input, h1, h2, h3, h4]) + + h5 = _conv_block(h4, activation=False) + + h5 = Lambda(lambda x: x * 0.2)(h5) + h = Add()([h5, input]) + + return h + +def rrdb_block(input): + h = dense_block(input) + h = dense_block(h) + h = dense_block(h) + h = Lambda(lambda x: x * 0.2)(h) + out = Add()([h, input]) + return out + +def upsample(x, filters, use_bias=True): + x = Conv2DTranspose(filters, kernel_size=[3, 3], + strides=[2, 2], padding='same', + use_bias=use_bias)(x) + x = LeakyReLU(alpha=0.2)(x) + return x + +def generator_network(HParams, + num_filters=32, + out_channels=3): + """ + The Generator network for ESRGAN consisting of Residual in Residual Block + as the basic building unit. + + Args : + num_filters : Number of num_filters for the convolutional layers used. + out_channels : Number of channels for the generated image. + use_bias : Whether to use bias or not for the convolutional layers. + + Returns: + The compiled model of the generator network where the inputs and outputs + of the model are defined as : + inputs -> Batch of tensors representing LR images. + outputs -> Batch of generated HR images. + """ + lr_input = Input(shape=(HParams.hr_dimension//HParams.scale, + HParams.hr_dimension//HParams.scale, 3)) + + x = Conv2D(num_filters, kernel_size=[3, 3], strides=[1, 1], + padding='same', use_bias=True)(lr_input) + x = LeakyReLU(0.2)(x) + + ref = x + + for _ in range(HParams.trunk_size): + x = rrdb_block(x) + + x = Conv2D(num_filters, kernel_size=[3, 3], strides=[1, 1], + padding='same', use_bias=True)(x) + x = Add()([x, ref]) + + x = upsample(x, num_filters) + x = upsample(x, num_filters) + + x = Conv2D(num_filters, kernel_size=[3, 3], strides=[1, 1], + padding='same', use_bias=True)(x) + x = LeakyReLU(0.2)(x) + hr_output = Conv2D(out_channels, kernel_size=[3, 3], strides=[1, 1], + padding='same', use_bias=True)(x) + + model = Model(inputs=lr_input, outputs=hr_output) + return model + + +def discriminator_network(HParams, + num_filters=64, + training=True): + """ + The discriminator network for ESRGAN. + + Args : + num_filters : Number of filters for the first convolutional layer. + Returns : + The compiled model of the discriminator network where the inputs + and outputs of the model are defined as : + inputs -> Batch of tensors representing HR images. + outputs -> Predictions for batch of input images. + """ + img = Input(shape=(HParams.hr_dimension, HParams.hr_dimension, 3)) + + x = Conv2D(num_filters, [3,3], 1, padding='same', use_bias=False)(img) + x = BatchNormalization()(x) + x = LeakyReLU(alpha=0.2)(x) + + x = Conv2D(num_filters, [3,3], 2, padding='same', use_bias=False)(x) + x = BatchNormalization()(x) + x = LeakyReLU(alpha=0.2)(x) + + x = _conv_block_d(x, num_filters *2) + x = _conv_block_d(x, num_filters *4) + x = _conv_block_d(x, num_filters *8) + + x = Flatten()(x) + x = Dense(100)(x) + x = LeakyReLU(alpha=0.2)(x) + x = Dense(1)(x) + + model = Model(inputs=img, outputs=x) + return model diff --git a/tensorflow_gan/examples/esrgan/networks_test.py b/tensorflow_gan/examples/esrgan/networks_test.py new file mode 100644 index 0000000..9c41636 --- /dev/null +++ b/tensorflow_gan/examples/esrgan/networks_test.py @@ -0,0 +1,66 @@ +# coding=utf-8 +# Copyright 2021 The TensorFlow GAN Authors. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Tests for tfgan.examples.esrgan.networks""" + +from __future__ import absolute_import +from __future__ import division +from __future__ import print_function + +import tensorflow as tf +import networks +import collections + +Params = collections.namedtuple('HParams', ['hr_dimension', + 'scale', + 'trunk_size']) +class NetworksTest(tf.test.TestCase): + def setUp(self): + self.HParams = Params(256, 4, 11) + self.generator = networks.generator_network(self.HParams) + self.discriminator = networks.discriminator_network(self.HParams) + + def test_network_type(self): + """ Verifies that the models are of keras.Model type """ + self.assertIsInstance(self.generator, tf.keras.Model) + self.assertIsInstance(self.discriminator, tf.keras.Model) + + def test_generator(self): + """ Verifies the generator output shape.""" + img_batch = tf.random.uniform([3, 64, 64, 3]) + target_shape = [3, 256, 256, 3] + model_output = self.generator(img_batch) + with self.cached_session() as sess: + sess.run(tf.compat.v1.global_variables_initializer()) + self.assertEqual(model_output.shape, target_shape) + + def test_generator_inference(self): + """ Check one inference step.""" + img_batch = tf.zeros([2, 64, 64, 3]) + model_output, _ = self.generator(img_batch) + with self.cached_session() as sess: + sess.run(tf.compat.v1.global_variables_initializer()) + sess.run(model_output) + + def test_discriminator(self): + img_batch = tf.zeros([3, 256, 256, 3]) + disc_output = self.discriminator(img_batch) + with self.cached_session() as sess: + sess.run(tf.compat.v1.global_variables_initializer()) + sess.run(disc_output) + + +if __name__ == '__main__': + tf.test.main() diff --git a/tensorflow_gan/examples/esrgan/train.py b/tensorflow_gan/examples/esrgan/train.py new file mode 100644 index 0000000..90a4b54 --- /dev/null +++ b/tensorflow_gan/examples/esrgan/train.py @@ -0,0 +1,82 @@ +# coding=utf-8 +# Copyright 2021 The TensorFlow GAN Authors. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from absl import flags, logging, app +import train_lib +import data_provider + +flags.DEFINE_integer('batch_size', 4, + 'The number of images in each batch.') +flags.DEFINE_string('model_dir', '/content/', + 'Directory to save and load trained models') +flags.DEFINE_boolean('phase_1', False, + 'Whether Phase 1 training is done or not') +flags.DEFINE_boolean('phase_2', False, + 'Whether Phase 2 training is done or not') +flags.DEFINE_integer('hr_dimension', 128, + 'Dimension of a HR image.') +flags.DEFINE_integer('scale', 4, + 'Factor by which LR images are downscaled.') +flags.DEFINE_integer('trunk_size', 11, + 'Number of Residual blocks for Generator.') +flags.DEFINE_string('data_dir', '/content/datasets', + 'Directory to save DIV2K dataset.') +flags.DEFINE_integer('print_steps', 1000, + 'Steps at which values are displayed during training.') +flags.DEFINE_integer('total_steps', 1, + 'The maximum number of steps for training.') +flags.DEFINE_integer('decay_steps', 50000, + 'Step at which learning rate is modified.') +flags.DEFINE_float('decay_factor', 0.2, + 'Factor by which learning rate is modified.') +flags.DEFINE_float('lr', 0.0002, + 'Value of initial learning rate for phase 1 generator') +flags.DEFINE_float('beta_1', 0.9, + 'Optimizer parameters') +flags.DEFINE_float('beta_2', 0.99, + 'Optimizer parameters') +flags.DEFINE_float('init_lr', 0.00005, + 'Value of initial learning rate for phase 2 generator') +flags.DEFINE_string('loss_type', 'L1', + 'L1 or L2 loss while computing perceptual loss.') +flags.DEFINE_float('lamda_', 0.005, + 'Constant while computing generator loss') +flags.DEFINE_float('eta', 0.02, + 'Constant while computing generator loss') +flags.DEFINE_string('image_dir', 'L1', + 'Directory to save images generated during training.') + + +FLAGS = flags.FLAGS + +def main(_): + hparams = train_lib.HParams(FLAGS.batch_size, FLAGS.scale, + FLAGS.model_dir, FLAGS.phase_1, + FLAGS.phase_2, FLAGS.hr_dimension, + FLAGS.data_dir, FLAGS.print_steps, + FLAGS.trunk_size, FLAGS.total_steps, + FLAGS.decay_steps, FLAGS.decay_factor, + FLAGS.lr, FLAGS.beta_1, + FLAGS.beta_2, FLAGS.init_lr, + FLAGS.loss_type, FLAGS.lamda_, + FLAGS.eta, FLAGS.image_dir) + + data = data_provider.get_div2k_data(hparams, mode='train') + train_lib.pretrain_generator(hparams, data) + train_lib.train_esrgan(hparams, data) + +if __name__ == '__main__': + logging.set_verbosity(logging.INFO) + app.run(main) diff --git a/tensorflow_gan/examples/esrgan/train_lib.py b/tensorflow_gan/examples/esrgan/train_lib.py new file mode 100644 index 0000000..fdf0d3b --- /dev/null +++ b/tensorflow_gan/examples/esrgan/train_lib.py @@ -0,0 +1,275 @@ +# coding=utf-8 +# Copyright 2021 The TensorFlow GAN Authors. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Train the ESRGAN model +See https://arxiv.org/abs/1809.00219 for details about the model. +""" + +import tensorflow as tf +import collections +import os +from absl import logging +from networks import generator_network, discriminator_network +from losses import pixel_loss, vgg_loss, ragan_generator_loss, ragan_discriminator_loss +from utils import preprocess_input, get_psnr, visualize_results, network_interpolation + +HParams = collections.namedtuple('HParams', [ + 'batch_size', 'scale', + 'model_dir', 'phase_1', + 'phase_2', 'hr_dimension', + 'data_dir', 'print_steps', + 'trunk_size', 'total_steps', + 'decay_steps', 'decay_factor', + 'lr', 'beta_1', + 'beta_2', 'init_lr', + 'loss_type', 'lambda_', + 'eta', 'image_dir']) + +def pretrain_generator(HParams, data): + """ Pre-trains the generator network with pixel-loss as proposed in + the paper and saves the network inside the model directory specified. + + Args: + HParams : Training parameters as proposed in the paper. + data : Dataset consisting of LR and HR image pairs. + """ + + # Stores mean L1 values and PSNR values obtained during training. + metric = tf.keras.metrics.Mean() + psnr_metric = tf.keras.metrics.Mean() + + # If phase_1 training is done, load that generator model. + if HParams.phase_1: + generator = tf.keras.load_model(HParams.model_dir + '/Phase_1/generator/') + # If pre-trained model is not available, start training from the beginning + else: + generator = generator_network(HParams) + + logging.info("Starting Phase-1 training of generator using only pixel loss function.") + + G_optimizer = _get_optimizer() + + def train_step(image_lr, image_hr): + """ Calculates the L1 Loss and gradients at each step, and updates the + gradient to improve the PSNR values. + Args: + image_lr : batch of tensors representing LR images. + image_hr : batch of tensors representing HR images. + + Returns: + PSNR values and generator loss obtained in each step. + """ + with tf.GradientTape() as tape: + fake = generator(image_lr) + + gen_loss = pixel_loss(image_hr, fake) * (1.0 / HParams.batch_size) + psnr = get_psnr(image_hr, fake) + + gradient = tape.gradient(gen_loss, generator.trainable_variables) + G_optimizer.apply_gradients(zip(gradient, generator.trainable_variables)) + + return psnr, gen_loss + + step = 0 + for lr, hr in data.take(HParams.total_steps): + step += 1 + lr = tf.cast(lr, tf.float32) + hr = tf.cast(hr, tf.float32) + + psnr, gen_loss = train_step(lr, hr) + + # Calculate the mean loss and PSNR values obtained during training. + metric(gen_loss) + psnr_metric(psnr) + + if step % HParams.print_steps == 0: + logging.info("Step: {}\tGenerator Loss: {}\tPSNR: {}".format( + step, metric.result(), psnr_metric.result())) + + # Modify the learning rate as mentioned in the paper. + if step % HParams.decay_steps == 0: + G_optimizer.learning_rate.assign( + G_optimizer.learning_rate * HParams.decay_factor) + + # Save the generator model inside model_dir. + os.makedirs(HParams.model_dir + '/Phase_1/generator', exist_ok=True) + generator.save(HParams.model_dir + '/Phase_1/generator') + logging.info("Saved pre-trained generator network succesfully!") + +def train_esrgan(HParams, data): + """Loads the pre-trained generator model and trains the ESRGAN network + using L1 Loss, Perceptual loss and RaGAN loss function. + + Args: + HParams : Training parameters as proposed in the paper. + data : Dataset consisting of LR and HR image pairs. + """ + # If the phase 2 training is done,load thd trained networks. + if HParams.phase_2: + generator = tf.keras.models.load_model(HParams.model_dir + + 'Phase_2/generator/') + discriminator = tf.keras.models.load_model(HParams.model_dir + + 'Phase_2/discriminator/') + # If Phase 2 training is not done, then load the pre-trained generator model. + else: + try: + generator = tf.keras.models.load_model(HParams.model_dir + + '/Phase_1/generator') + except: + raise FileNotFoundError('Pre-trained Generator model not found!') + + + discriminator = discriminator_network(HParams) + + logging.info("Starting Phase-2 training of ESRGAN") + + # Generator learning rate is set as 1 x 10^-4. + G_optimizer = _get_optimizer(lr=HParams.init_lr) + D_optimizer = _get_optimizer() + + # Define RaGAN loss for generator and discriminator networks. + #ra_gen = relativistic_avg_loss_g(discriminator) + #ra_disc = relativistic_avg_loss_d(discriminator) + + # Define the Perceptual loss function and + # pass 'imagenet' as the weight for the VGG-19 network. + perceptual_loss = vgg_loss( + weight="imagenet", + input_shape=[HParams.hr_dimension, HParams.hr_dimension, 3]) + + gen_metric = tf.keras.metrics.Mean() + disc_metric = tf.keras.metrics.Mean() + psnr_metric = tf.keras.metrics.Mean() + + def train_step(image_lr, image_hr, step): + """ Calculates the L1 Loss, Perceptual loss and RaGAN loss, to train + both generator and discriminator networks of the ESRGAN model. + Args : + image_lr : batch of tensors representing LR images. + image_hr : batch of tensors representing HR images. + + Returns : + PSNR values, generator loss and discriminator obtained in each step. + """ + with tf.GradientTape() as gen_tape, tf.GradientTape() as disc_tape: + gen = generator(image_lr) + + fake = preprocess_input(gen) + image_lr = preprocess_input(image_lr) + image_hr = preprocess_input(image_hr) + + percep_loss = tf.reduce_mean(perceptual_loss(image_hr, fake)) + l1_loss = pixel_loss(image_hr, fake) + + loss_RaG = ragan_generator_loss(discriminator(image_hr), + discriminator(fake)) + disc_loss = ragan_discriminator_loss(discriminator(image_hr), + discriminator(fake)) + #loss_RaG = ra_gen(image_hr, fake) + #disc_loss = ra_disc(image_hr, fake) + + gen_loss = percep_loss + HParams.lambda_ * loss_RaG + HParams.eta * l1_loss + + gen_loss = gen_loss * (1.0 / HParams.batch_size) + disc_loss = disc_loss * (1.0 / HParams.batch_size) + psnr = get_psnr(image_hr, fake) + + + disc_grad = disc_tape.gradient(disc_loss, + discriminator.trainable_variables) + D_optimizer.apply_gradients(zip(disc_grad, + discriminator.trainable_variables)) + + gen_grad = gen_tape.gradient(gen_loss, + generator.trainable_variables) + G_optimizer.apply_gradients(zip(gen_grad, + generator.trainable_variables)) + + return gen_loss, disc_loss, psnr + + def val_step(image_lr, image_hr, step): + """ Saves an image grid containing LR image, generated image and + HR image, inside the image directory. + Args: + image_lr : Low Resolution Image + image_hr : High Resolution Image. + step : Number of steps completed, used for naming the image + file. + """ + fake=generator(image_lr) + visualize_results(image_lr, + fake, + image_hr, + HParams.image_dir, + step=step) + + step = 0 + # Modify learning rate at each of these steps + decay_list = [50000, 100000, 200000, 300000] + + for lr, hr in data.take(HParams.total_steps): + step += 1 + lr = tf.cast(lr, tf.float32) + hr = tf.cast(hr, tf.float32) + + gen_loss, disc_loss, psnr = train_step(lr, hr, step) + + gen_metric(gen_loss) + disc_metric(disc_loss) + psnr_metric(psnr) + + if step % HParams.print_steps == 0: + logging.info("Step: {}\tGenerator Loss: {}\tDiscriminator: {}\tPSNR: {}" + .format(step, gen_metric.result(), disc_metric.result(), + psnr_metric.result())) + + val_step(lr, hr, step) + + # Modify the learning rate as mentioned in the paper. + if step >= decay_list[0]: + G_optimizer.learning_rate.assign( + G_optimizer.learning_rate * HParams.decay_factor) + + D_optimizer.learning_rate.assign( + D_optimizer.learning_rate * HParams.decay_factor) + + decay_list.pop(0) + + # Save the generator model inside model_dir. + os.makedirs(HParams.model_dir + '/Phase_2/generator', exist_ok=True) + generator.save(HParams.model_dir + '/Phase_2/generator') + logging.info("Saved trained ESRGAN generator succesfully!") + + interpolated_generator = network_interpolation( + phase_1_path=HParams.model_dir + '/Phase_1/generator', + phase_2_path=HParams.model_dir + '/Phase_2/generator') + + #Save interpolated generator + os.makedirs(HParams.model_dir + + '/Phase_2/interpolated_generator', exist_ok=True) + interpolated_generator.save(HParams.model_dir + + '/Phase_2/interpolated_generator') + + logging.info("Saved interpolated generator network succesfully!") + +def _get_optimizer(lr=0.0002): + """Returns the Adam optimizer with the specified learning rate.""" + optimizer = tf.optimizers.Adam( + learning_rate=lr, + beta_1=0.9, + beta_2=0.99 + ) + return optimizer + diff --git a/tensorflow_gan/examples/esrgan/train_test.py b/tensorflow_gan/examples/esrgan/train_test.py new file mode 100644 index 0000000..ecea0b7 --- /dev/null +++ b/tensorflow_gan/examples/esrgan/train_test.py @@ -0,0 +1,69 @@ +# coding=utf-8 +# Copyright 2021 The TensorFlow GAN Authors. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Tests for tfgan.examples.esrgan.train""" + +from __future__ import absolute_import +from __future__ import division +from __future__ import print_function + +from absl.testing import absltest +import os +import collections + +import tensorflow as tf +import train_lib + +mock = tf.compat.v1.test.mock +HParams = collections.namedtuple('HParams', [ + 'batch_size', 'scale', + 'model_dir', 'phase_1', + 'phase_2', 'hr_dimension', + 'data_dir', 'print_steps', + 'trunk_size', 'total_steps', + 'decay_steps', 'decay_factor', + 'lr', 'beta_1', + 'beta_2', 'init_lr', + 'loss_type', 'lambda_', + 'eta', 'image_dir']) + +class TrainTest(tf.test.TestCase): + def setUp(self): + self.HParams = HParams(32, 4, '/content/', + False, False, 256, + '/content/', 1, 11, 1, 1, + 0.5, 0.0001, 0.5, 0.001, 0.00005, + 'L1', 0.001, 0.5, '/content/') + d = tf.data.Dataset.from_tensor_slices(tf.random.normal([32, 256, 256, 3])) + def lr(hr): + lr = tf.image.resize(hr, [64, 64], method='bicubic') + return lr, hr + + d = d.map(lr) + d = d.batch(2) + self.mock_dataset = d + + def test_pretrain_generator(self): + """ Executes all the processes inside the phase-1 training step, once. + (takes about 100s)""" + self.assertIsNone(train_lib.pretrain_generator(self.HParams, self.mock_dataset)) + + def test_train_generator(self): + """ Executes the phase-2 training step for a single step, once + (takes about 220s)""" + self.assertIsNone(train_lib.train_esrgan(self.HParams, self.mock_dataset)) + +if __name__ == '__main__': + tf.test.main() diff --git a/tensorflow_gan/examples/esrgan/utils.py b/tensorflow_gan/examples/esrgan/utils.py new file mode 100644 index 0000000..ff8adf8 --- /dev/null +++ b/tensorflow_gan/examples/esrgan/utils.py @@ -0,0 +1,186 @@ +# coding=utf-8 +# Copyright 2021 The TensorFlow GAN Authors. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import os +import tensorflow as tf +import tensorflow_gan as tfgan +from absl import logging +import PIL +import numpy as np + + +def preprocess_input(image): + """ Preprocessing of images done before calculating loss + functions during training.""" + image = image[..., ::-1] + mean = -tf.constant([103.939, 116.779, 123.68]) + return tf.nn.bias_add(image, mean) + +# Utility functions for training +def visualize_results(image_lr, + generated, + image_hr, + image_dir='', + step=0, + train=True): + + """ Creates an image grid using Tf-GAN's image grid function and + saves the results as a .png image. + + Args: + image_lr : batch of tensors representing LR images. + generated : batch of tensors representing generated images. + image_hr : batch of tensors representing HR images. + image_dir : Directory to save the results. + step : Number of steps completed, for naming purposes. + train : Training or Validation. + """ + # Resizing all images to 256x256 just for visualization + size = 256 + resized_lr = tf.image.resize( + image_lr, [size, size], method=tf.image.ResizeMethod.BILINEAR) + resized_gen = tf.image.resize( + generated, [size, size], method=tf.image.ResizeMethod.BILINEAR) + resized_hr = tf.image.resize( + image_hr, [size, size], method=tf.image.ResizeMethod.BILINEAR) + + # Stack images in the order LR, Generated and HR for display + stack = tf.stack([resized_lr[0], resized_gen[0], resized_hr[0]]) + + # Generate an image grid using tf-gan's image grid function. + image_grid = tfgan.eval.python_image_grid(stack, grid_shape=(1, 3)) + result = PIL.Image.fromarray(image_grid.astype(np.uint8)) + + if image_dir: + if train: + os.makedirs(image_dir + 'training_results', exist_ok=True) + result.save(image_dir + 'training_results/' + 'step_{}.png'.format(step)) + else: + os.makedirs(image_dir + 'validation_results', exist_ok=True) + result.save(image_dir + 'validation_results/' + 'step_{}.png'.format(step)) + + +def network_interpolation(alpha=0.2, + phase_1_path=None, + phase_2_path=None): + """ Network interpolation as explained in section 3.4 in the paper, bascically + balancing the effects of PSNR oriented methods and GAN based methods. + Args: + alpha : interpolation parameter. + phase_1_path : path to the network saved after phase 1 training. + phase_2_path : path to the network saved after phase 2 training. + Returns: + Interpolated generator network. + """ + if phase_1_path is None or phase_2_path is None: + raise ValueError( + 'Please specify paths to both phase 1 and phase 2 generators.') + + psnr_gen = tf.keras.models.load_model(phase_1_path) + gan_gen = tf.keras.models.load_model(phase_2_path) + + for var_1, var_2 in zip(gan_gen.trainable_variables, + psnr_gen.trainable_variables): + var_1.assign((1 - alpha) * var_2 + alpha * var_1) + + return gan_gen + +# Utility functions for evaluation +def get_frechet_inception_distance(real_images, generated_images, batch_size, + num_inception_images): + """ Get Frechet Inception Distance between real and generated images. + + Args: + real_images: Real images minibatch. + generated_images: Generated images minibatch. + batch_size: Batch dimension. + num_inception_images: Number of images to run through Inception at once. + + Returns: + Frechet Inception distance. A floating-point scalar. + + Raises: + ValueError: If the minibatch size is known at graph construction time, and + doesn't batch `batch_size`. + """ + # Validate input dimensions. + real_images.shape[0:1].assert_is_compatible_with([batch_size]) + generated_images.shape[0:1].assert_is_compatible_with([batch_size]) + + # Resize input images. + size = tfgan.eval.INCEPTION_DEFAULT_IMAGE_SIZE + resized_real_images = tf.image.resize( + real_images, [size, size], method=tf.image.ResizeMethod.BILINEAR) + resized_generated_images = tf.image.resize( + generated_images, [size, size], method=tf.image.ResizeMethod.BILINEAR) + + # Compute Frechet Inception Distance. + num_batches = batch_size // num_inception_images + fid = tfgan.eval.frechet_inception_distance( + resized_real_images, resized_generated_images, num_batches=num_batches) + + return fid + + +def get_inception_scores(images, batch_size, num_inception_images): + """ Calculate Inception score for images. + + Args: + images : A batch of tensors representing series of images. + batch_size : Integer representing batch dimension. + num_inception_images : Number of images to run through Inception at once. + + Returns: + Inception scores : A tensor consisting of scores for each batch of images. + + Raises: + ValueError: If `batch_size` is incompatible with the first dimension of + `images` + ValueError: If `batch_size` isn't divisible by `num_inception_images`. + """ + + # Validate inputs. + images.shape[0:1].assert_is_compatible_with([batch_size]) + if batch_size % num_inception_images != 0: + raise ValueError( + '`batch_size` must be divisible by `num_inception_images`.') + + # Resize images. + size = tfgan.eval.INCEPTION_DEFAULT_IMAGE_SIZE + resized_images = tf.image.resize( + images, [size, size], method=tf.image.ResizeMethod.BILINEAR) + + # Run images through Inception. + num_batches = batch_size // num_inception_images + + inc_score = tfgan.eval.inception_score( + resized_images, num_batches=num_batches) + + return inc_score + +def get_psnr(real, generated): + """ Calculate PSNR values for the given samples of images. + + Args: + real: batch of tensors representing real images. + generated : batch of tensors representing generated images. + + Returns: + PSNR value for the given batch of real and generated images. + """ + psnr_value = tf.reduce_mean(tf.image.psnr( + generated, real, max_val=256.0)) + + return psnr_value diff --git a/tensorflow_gan/examples/esrgan/utils_test.py b/tensorflow_gan/examples/esrgan/utils_test.py new file mode 100644 index 0000000..bad0034 --- /dev/null +++ b/tensorflow_gan/examples/esrgan/utils_test.py @@ -0,0 +1,79 @@ +# coding=utf-8 +# Copyright 2021 The TensorFlow GAN Authors. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Tests for tfgan.examples.esrgan.utils""" + +from __future__ import absolute_import +from __future__ import division +from __future__ import print_function + +from absl.testing import absltest +import os +import collections + +import tensorflow as tf +import utils, networks + + +Params = collections.namedtuple('HParams', ['hr_dimension', + 'scale', + 'trunk_size', + 'path']) + +class UtilsTest(tf.test.TestCase): + def setUp(self): + super(UtilsTest, self).setUp() + self.HParams = Params(256, 4, 11, '/content/') + + self.generator1 = networks.generator_network(self.HParams) + self.generator1.save(self.HParams.path+'1/') + self.generator2 = networks.generator_network(self.HParams) + self.generator1.save(self.HParams.path+'2/') + + self.hr_data = tf.random.normal([2,256,256,3]) + self.lr_data = tf.random.normal([2,64,64,3]) + self.gen_data = tf.random.normal([2,256,256,3]) + + def test_visualize_results(self): + """ To test display grid function. The function doesn't return anything if no + error is found.""" + self.assertIsNone(utils.visualize_results(self.lr_data, + self.gen_data, + self.hr_data)) + def test_psnr(self): + psnr = utils.get_psnr(self.hr_data, self.gen_data) + self.assertEqual(psnr.dtype, tf.float32) + + def test_fid_score(self): + fid_value = utils.get_frechet_inception_distance(self.hr_data, + self.gen_data, + batch_size=2, + num_inception_images=2) + self.assertEqual(fid_value.dtype, tf.float32) + + def test_inception_score(self): + is_score = utils.get_inception_scores(self.gen_data, + batch_size=2, + num_inception_images=2) + self.assertEqual(is_score.dtype, tf.float32) + + def test_interpolation(self): + """ To test the interpolation function. """ + inter_gen = utils.network_interpolation(phase_1_path=self.HParams.path+'1/', + phase_2_path=self.HParams.path+'2/') + self.assertEqual(type(inter_gen), type(self.generator1)) + +if __name__ == '__main__': + tf.test.main() From d8433328d812a7cef946c2120d84c5b88c596013 Mon Sep 17 00:00:00 2001 From: supertramp2 Date: Thu, 19 Aug 2021 01:19:05 +0530 Subject: [PATCH 02/20] add images --- .../examples/esrgan/images/result1.png | Bin 0 -> 203983 bytes .../examples/esrgan/images/result2.png | Bin 0 -> 156577 bytes 2 files changed, 0 insertions(+), 0 deletions(-) create mode 100644 tensorflow_gan/examples/esrgan/images/result1.png create mode 100644 tensorflow_gan/examples/esrgan/images/result2.png diff --git a/tensorflow_gan/examples/esrgan/images/result1.png b/tensorflow_gan/examples/esrgan/images/result1.png new file mode 100644 index 0000000000000000000000000000000000000000..ac5defe2889858fd42fa8f498e823dd97b0379c2 GIT binary patch literal 203983 zcmV)KK)Sz)P)GGik(PEq70A_B*8HJVn5h048yPf1vcOZ zKNzqLiK0Qtl1z#$Ruzk^Vr6D!-kW**)1R~VIlEu|T(ci-_~G2N>G?J$#)uIS^C9Ml z5%GQa|M7qMPpyNqX?c2GP8YRqw5koUE+QnPq}68Gs8ub6$HPE`q31``izxRg20#vR z#*!$GqZnf@4JeIFD{b4lw$X?fOcmg=EQ_jYn${|C3K$`g&*OlD1Ffx5CJ4hg38N&8 zM?o_3S1R@XiN~MC>}@2IF5(DpMswP69^0eOBp6U zCmzFo?EKVviLqtZ<~?ZAUc!3`_d{q{Ub6x-8qj{g2C~A%S{Ipq^>TWAa&>k(_rll@ zBH;yu040cGBrxI_bM6a~a4#v_t*>Z|XpC5dglD;Mf|G!SJ`3B*uI9yRULp+K zC)}r@=!U%O(O6ZDsv6lg(zen{ha4q@5*o#R+6z0~Xj8joY1XANMWc%*B>4S%d+*=f z9rV0XZc4dPP5}akQR>mI&pJNMO}o);r8QWFEM?B~QQ)J%5!N!048T>`7T6XD_7OTn zcHGwUww@VN(aD6!qyUF5x}GAMPHCK^d3L>(rT|p0ptExzxw%TJTQps zroqT+z**HW&IZHYt)oG%OY4|+z=?`^*pGW*I4}rZ&8AYaPJ{_os#SrXIt;5yE!XR` z6JMUs!6L0Or;SsEGG=f0#$vV672zR%`~Gc(Y$;{8FW-Oj&O*LCKW{ExRLK^3_we@R zd3*ip?BV(Ka6A@BTS~>&9u2GALDU)?cFOVg&Kqxz78mlXpFeLx@y5NR7h)2WT^y$@ z3H{{ac(c8I57|lt?a!Zl74`7#y}LJW+*q#iS69-C{x^T|vsMQ`{mauJP6X!Ne&0|w z8m82=5z&ULh22A8ub=KfXA=+&S9a6jMJU#=4bi`?1##Kv}ahIDGoz z7Fge){WxiGELi{pI?`&08dL5hWyXMyp3(9uK#A zH}>{kzF15zu8+3f=RT=TMf?aje)#RTwIaQ6+>4`bdiPXS^RuU%VQnD}{m}P2gJGK& zooHXy*X^3WgJ7naAd@R(alV z%p&1$^?c=E6<1M{a?Zh&{hd9W=%YLP#WV|ccPNDO+4bt|^vzK}o%H_VufASfW${)z zdy;!&@6IQ0YN&i)u?Y2tVcPGtt-4yDd6;sUjDwsE?D=*1JHPe2L;sy${L#OPCxiFj zy0ctmm)YaNPGV@?>+Ng@KL8lb>lb*6{>6X&M~|Lgkm01;?_M0g+}#%(4uY_i$O#S=adBF?cRgxd8&hg-Rs`4RU~gRZ6pNg+sS zv2opQXLoCI_N)1w?+-lG`RbQXspokISv_}9peK*kAO7Usbd(qqRM*p56^ZE3x-nEc zhu?U!-zEKzjt)gqzF0lWSITqVMP0pddkaxVOB?iu*YibzugV;Uk&p$KTKQ7l{$SLo zepL&jH>u8*?Ph$qzkc|1)Vm{B#dKLju^bNWF$c&w z1b{HcgkVevp#(dGFb0GG5CQ;%5JCtej1WTT^$-AI1PBlS0ze1>IB*US07i%qOaNnq z@OP^L0eU?d0m84PeJ2oO{O^fH7y-f^ z7J)|INO?aVNZ9 z@!h81`3~^Er#k=w2LRx{lL!ES@M~9q1F(SHcgFr^m;aynzwwDr5MfSPZMeUvlt&pM z>T2B#cRde?LT))sWJ;sVXwqXIkAgJil=~6(&}4tyT3D@C7xRm4)jd9JJIQv7=26cz zg<7tzfB$d%&cFKCHf?m;iLPGF2R--uKYsh`vx|KC`0Q#L9gSXW=#^ZCwTlw3I|<7+ zGqN_VpJUhM+L+enq*BL|onegijoTv?`D+Y0u3PJeU5`?8?}ImuBz5gQ{_?RVI9nSQ zcsj;G;Bi10Y(Gu2Y#BpJdA&V3+S}clpZ(KU$B%aJA2?kqs}J_NjO+0ryf`bVaD!pj zYP2rO(n2-QkTttrH%_8yw$T(Chp0gPes8ebd-3?GGrAY!cYpYYkDi~fGAASwQG5FA z`5+3rQ9uNoXNzak!bPr9@iHsUvU+QHduOLBX=xRrw6MhWw}%@`KY#wJUe?Rpj&^hh z(^e~O6=QC1cM^s{OGM6QYn~$xm7{&t6qGjzVS- z5WCCoR<*43Mg!-7IVQC!8;r8(o~I|({Gu(VTf4;8Wh4f(lShH?E$ejS=qKFLIkmx*q9@RNT8W>G(ya0jCmNaliC_g1!0_Wim7wh0RhW>=lPhjIEc3U zqr}k4($dj}Qb(zy2opn0Yi;d_!9He$5zpgZ$QWiATMLcj5`_jahg(b}rI`5v4+0@L zLx9^{tJc^?qt${58MVFL&Q1ptf?E>}|s!o@E_VIyc+^X{@VY$ z*AiI=`LfFDTFW+!QC&Ff8H4e&8Ghpwuli` zHsEk1(4^bN&elqIAgz>4LIKQ=Z|vWm1Smj@Y~C(nRTd08k9vbadNIB7C_A__!L3b% zzv7BUc7J>Ft6yFI<)3^y*zTnL-KWn#uX7y+9&*)X>jhL?KVJ@le)7r6@4d0#k8D$) zU(a?t;iqAVUnQ(t$ubQ3X;l_LZhf#H?88@IZj_GCpT9JQ1UlmK+ZpvK*>}5>(6+?XWLcLpT4`BuGcM|%bkz>tBWRVohvKRYiO{&xz4JR zOy^lGSAFl2wR7Ahoi&0RYCOL4^_S0TVv6PB?eEBDV6}D14YsYf?ff2a!I&3dhfPtmYm5l; zC~+Z2%;5l0Vp)Wk&nOevBC8F-4ujx?2*AiVY#gDM5%7EziHOjc5LD}Vqh_rE3=Sgz z4OWAxt!*sT*dv^C=6k{qJaEKWW2|*dBW5sn1Yv9#qcn{DwBuukbYt5>DXEQANE&9b zAS4kY^tk5<#)LCm7EDkUc;S!-m?#I0(G6HiEN2#5=d86x8!0VFi800=A|6QTn%Xoq zLbS$I6S@io4h0s16Au%?31t`|gsj6DA%cJ)gp4uP*z@br!=J~&jYaxdalRTp(rmknh^^n&4Vt6o>Ns_Tt>{^;W7&V-YR1vj6s zkOqlW=m+bp;yf%GTNJkMbt_Q@f$)Tw&Z~=yneX|XUdPa8kVgAQ2g*;foP;U;-f#bC zaeeXX*|XbsZlc;0sQKuF_Z)H6>663Z;M2McsBcTIT4D>iA$=;(eTuTgIV0K{&R?jl zk)LdPQUnbfGY$@wmnTohJo)mgN2h~VgROgkYnW7qC`a}7I0{1{*R8M`OAci%BCnHl z2i>%mM(ZYt$=h%J96FtlNXQEG)iKV`dlE)YO@!N+6}nOt+e5Z zKNa7;Jj~a%U19fn3)Ts61N#TcGl{Y{B8y^LJfHXaM_R{mZWs8JJS2KyiT`3ng z$KLfupPj7!{*OOuWo?z$WZ_@`!T-FRw&A2tHg#Rq29PmKYeam^WzfpTTGwcOb$!kQ zVGQzx=*DTbLYLE%PU174GGFHF{QmaN>GiZWFxcrW=Vj0x=1SLf;d#OJbXG|5DdBgVnN}E@Wkt1Lv$ulOT#b!qGgtpt;V_7YbZRquRVa zefl&FZY`gkr$=|wts#%%H~DXKoqctA{AxPC@zDe?dE)V29EBrS`E}h^Kl*Fm`{)1n z)v7WwUemoL;~lIBj=U;c$$&T>T%5`N4QeJU+RilS8*km{(RO`JvsrhE7WwGm&d%G2 zpsVYrOlTssny+VHovdfeD2|je(I6c~0u}jiFj%iLQvj!?oNhk;tv3U{W2J4{)#FEB ziKM;ry(9?`E_k^vsM3_sAmB)mMwJN<_lFaMB`!&hm)<@fZ1wYYO>8Jd7xpCUJN$*z#I-c~SiE{Tt7gt5NS@v3UObf4kpr-UeY`&c5mt z+2uk7)Q1K1-t8=&DLVA$8<@2Z_SI1wf>t)0UnO2V+bCs`KD&4otl#@+EF-aL5o}0|Nt0X;0Nc(A%+p>$n$s@hH>19!Y~L#;8CA5k8*(-cGzhP#!-xY&V9~3#s%dBV*qEJ zcE~tt5CB`}17#sT*QqYNX05Fjv^SSk>Ym?sEB zfRzE~5J7|@h8!}+No`uK8Y5fN8ry=CMysZ=dG5-xshX_S3kwxtzy+s_;_tG87C-|S zKo$r90ce}7+Ek@pt*5P8M?L?Yw+|2RkF#3y#A^Xf(k1PijM32}@QiwR|f2@-dr zUM~)l=(oQA$>Hdx2&32w>)JMT{@}@r&%b@{3Gd~_>aBO)*&1|K^Le#edDwpS^!P{L z`^Y)gB}uCB$VR4!+IcG*Sro3!puEsm$Hi(@<%?;fRur#V0!##U8C{-~eh@!?a9-3a z%sP@lq2w}K19Fr7eh}f908>DuW|(kgkiK?LmyJv87}l{=tuK#}W5C z!Q)rctdP^yRhC^l11Xh0>k^;)S^2x4y#0H>_r~71Tc4WI!Q11bK~G*LiZ^-QmJPNB zDdHOp$Y5)#+-M2MCl^_xG6T|SE75YTR;yCP!MemdM|-l;qw(;iDsSF@H{O2Z`0+P# zwY;?-KRJF@){C;P27{5Q1EKnJjlaIU`qO{&=+U=}(fzHq;88E0FRQ#%%UR`=qnLOe z>-ADE3|y(r1_fAPil?hA>Vz&7Dwj774idu!b11JuFREkVl+NaP@1U!dyK{S7JF_a9 zMz}ImPnIvVk(bq+1mK+Rrin1BY0BFJGL#pcD~`US57$_And+lSG$eO^w2izX=t`K>S-EBlU$tnN!>gxmvqI;W z%{o&>TVqy#@WUvqs_nqBPl7Ac#CUO=f)T1(A16@+4okVEM85rbjEFr|oKK-O}MFor<7)SS+%lmWz)!7 zO63fqh>jnY&I;t6n8*R_^LP?m&o5++*f zwr$$7RjP2C${T~RKM2U6QHLazT@`wj17ZG+)H-%M-mpX(tY%5{f4q&xe zHdT88)Hz};Hq_y*t+<(hL7npaJ0m2N3=oC!jOV3c!=nX@!sRZTf>s~Y?q`8g5| zLxf?1Fv8r?5HQDJ8M4@6tgVxI1CBUHoFm3zYY`$i@O?iHgHVJq3nGfF5yC~W;~R@I z1IR{##h!>0L4{SOq?&QB?)DX<2tvCdwE-=WR7fI<5J42cDXSW-q+^VUh;c!#Rm0sw7`t^gmcaG}1vKln9j^MH>hyD2LhY!FT&+3IS3oz+m~Ya;qbdxx{*sZq9bTVSjSi6pACb$$0>e>A`s zFK3^A`q}q>a?dNlA%XY~Mu|^kfr_LPUtd3(eg2ns|BL_4<#Bm=dhO|rGv1GW{PwSu zDXt_c4YByutBc+J(faDbRxR=URCms;>J7G*XBWrlG*hcmUnxLImoeImqG-KZY)u9@ zB(uwPTiN}gH{3eNb7@*}QO-x*t|+0N%GGH$>~uP5$^v}7*bwA&laIH;$#9D?|M>As z@QsMf!NKToulvDWI=a*UH(xxvzFhqH@BJY3D_}G5gIuA4p^PG`NonggTan#v)kp6O(`p<4sYJnRwyP^Q#DnIG};;+$mMeWbSZjy*c)?)KmF-1%Enqs_V#$E zKiVDijJDT0E1Pz+l7IDd3gj7MqA4xMxHIT<`zcZqA)Ew(;6BnaLabGqVm_TOi%ieX z7IfTeJ#+l@q}T0CSLIc-4!jPl;p=ao11FEZI`J^t=yH41sSB;Nv((bVaA4!v@zi#F zS3!~2-L1aYP2#YN(=OK8_Hfrbc|N1);O6bp)?Fexfv=l}zZVa4_RXI?mbm@=k3W|+ z9`7WBbQ`W;1#N;WXB?S!bJ3?bR7jHZE9rs@5}$9Xyjmo9T|~%7E^N;ehJ%cpwmmzf zyFY#K)8u=}op+8xU;fGe?WxdgJnpXNWoMt!aS#`3ytRM!Ft@Z_U*zrci`nrd_j~a$ zS>~rf7u!&-3OyM!txzNaN$Y;6&s;YS+2~-ziul#(Ws*dv$5%?ZTDN=ZHf$$v|5!9D zG}#?5o6FGiw%;J>mUW!X=k;JKp-3O}M-MJ8w@2PlwXS(egUR;$?r=A?yr+g^zx{MV zgDYB%kWX zP;GRp3@REfIOm*TuvQwQ!`SO4>Gp6^8vu|vjTVU5#Tk}zg*B%*{9VU(#T!CbW6fdXuusB;3^ zI*ptL$0-q<5QH2URU0K8>u?csFQmdlLZDVVpiUX-BOy480}*%$7ehiK-K@%X1y*}R zc*GNo5{e1K7^4U0#qZyEV{)*qo}FE9$|7rhV=m84|H$Ja@lwDBdT55Cwx+z}$W%4XZ!JLP)Cg8-}AOStEY z)|#`E^Sv8ev+1%X&iUkevltHgqrH7_YCc;WUtVu*ZSB5!FDt=V;3UG%#$nnCyJX;H z^X0rEWmP|2e7@a3#ehpa}(j~MP6Zk zI37NE_z36i$>j-z^o@^3SC{j$W;+ML`Q=gwYPgXYIS)sX$9+t2vRp3eN=Ip!XBgRl zR`}|)eCOU9y>W+nOk1l+o+J_RNYo*x7t1(7ZQH(ccl6GUNtR6yKYqj3`T2bD^u@Ek z``6xIuZ`br47o0R)&#IT@66&Jvh5n$QbZM}eu0uh#M#C40on}q1k%4JU&K8R- zru2H#-n}!tb9Y~R-ua8G4#Z{MT5WV*O09C^VZe)7E*rJGlaz(pGY|&hb`(-f_x#Z> zpFE#kJ-oF)G8AoOg)pjGjRcxZ((O7a84=XK_+qx<#c;b*t{UzM+t%Ij-fWfS3d-|S zXi(VUm#g{sjr+@!uXICqCwC{?{a4w!*NqSJfUQPJJD9XX}BINW>#;m?!43O_uhm2=W+#NAb0PJ zn;&df=Vo>?mxTdn3GVcVq1I|V7?d4LMci$JuTH*UV$(d<5V_%dxP#Lu>?M(FvnrV& z9}6iRLRG|ri*HMCSBj}lJO~m^+Gcs4W%GG7if-TCT27Z5o1~LYc3SMz#0zILGcAkq zl^u6GcYd94Mxv>$)}K8@{sIUS^-bhjC#%i=-j%^{o7P8jGqmo}g_B4%Nf zVRhXijHojd3}Dk#rrsFjD8xW8;e>EXJl|8+NMp1%-_;9IggJg)K82kF>o5UIF&EU< zP&UnMwV{kKK`Ez%5ljgq6cbD-25^9!b`A*Q1Y-_FU?!*#td-UnV>D=~C?=F*%n{+3 zdY&J}ai`}jF1=b1-YV%@ZIr}-5fDNMF_ai?98wZWr4b@wgovO<+ahZ#t8`wNynvQ* z<~Xy6IEAqyMEJ~)l8DDi$dV2XQXF+z5DO7-jhway8604YeGeGZ*14+5vtqqiFRm9| zkJAqG9FrDV00J101LQEK3^|OEbD*V_m1dMOiU=W2BHI8KKoIqPF9>`91=fKD^xBgM zaYB908KszDhnxkYjr2IC+z5dTaxEBXw6>rvG7f>Im>>+;Xsfj`1`r13Vc}CQ5EDrF zGz?ji@FWpQ?8TAKnc$Q=N5O)X+8V_u1?t@E3Jih(qZQ!O(`9bzM6~U4E;r3~fMZ#G z`pxBoCyVdDarE-!>gMhcBW*Rdj&|db5dNxIHl=0}W!xqG2x}PWWAXq3D>h1CG|z^-oCZf-5Ozmzxe9urZk6p@!M}7{Og}S+m4dn_U_r^ z7cZWl#*t`B_3JOb8Fafz;7jKMpKa~$*{n`E^#Xr)XXwsKY(bUl&=*CS5hShau-eSd zD`=V4=9D#ew!61(59(D8+Q#YN>i7h_uoFe=rUq0vieX;QA737BN0Y&=xQqI@D&2gv zMR#_Rt5*dkC}e)f!r5~9;~)I6SIJtL!^7JVi5`CbImba7c*w9fwpe=e=Kfavi@$sj z(Uc<@Sg~&5!|(6T=EckFR~XZ#kx?W7aEJ2`-rOxKD;+Ns4EiGQy=GxIuu{+4G~l1o-vYQS$E>oCxz`sn*_jCIaZZfJ z2}|Tszc`yeKE4#T+j+B?&0$`)akt9@^x|xK)KN0#J^`knmqdUuAWb=mL%!ZLMP1`< zm8R6+LT3*ze&@q?%c`9!K^=ON_+-J9I_m;dGGcPHD1nck>> z@8kQ6tA|HobewH2H`2{aKgG@06s&=f@#J6M3{Hv;p!=^KPn%5BHK?EQh-4v_yPBP*QSY0(3BcA~EfpP%i3^*mN zGl}4pl+s2j%5d26!_cR3WP`93K7^5N;?gjvX%&ipr~D5H%>W^@xT|lk*e0FR!9{{F0fGq8Gx+9<3U5`CB9yk(-te%^`dcF)s3oa>l`qKgTOG_w2di?yvUW+#OK^+!e?AiSwNX9 zBLO482vKS|14f;ePSq9^!VFP_C_)ASLe@F3#u{m5rL9y}wW@7Z+o+~78d*(!#+*h) zF10iPhkn8cVF)uo#93?=(#mOY8k|9Z47e7MMY09!93nu7qsS5DkV9axFZgf}M?CNX z?g!lSJPbgfFsfm$rEF>V*r6&?0>Z@t0h%eIkO zxk(3|#{nkuWi&W1)`W@0GTYmW zv(2ircYD<|uC4Chzh?<(teLjI^~udIKl`fJ?KW-w!;jy5`RMtxP1~BRZB&}ZNI6Qx zrm83bjVPh1@>3hS?WEsbt%rhy9-Ce-s-Pe1R5j&r(!+7o zN_V*L-+23$X%z2JQ?3ULZAco%wY_R1h6N4!gF%>fIdXMXXAVbUbZ~3<^wqTs!{w%6 z*0hVpM$y53_vUuS+ zDyN-6ax&}_>OTF|aTI%1sdx7WlDMW&8`VgpLNCqADj<{#GMYq-3%T1H)TYuadF$;x zTCwNHry5qP>!NpXP-yp~Klq(r{Pa)HXDjfK+ zM|9`x>;Y(QP{T(4^mK*_+wr1m?zkALm7G7heEP*NZXDiYe!y7x>iPO7fABw<9{-!} z?s0N&y*qYyP{?w!OyejFJQ@pI zigK>w0mK9R_){qo-bzyC$l>|H0pS+waoJ(CZ}0;&HuF%aU}+4!Eas-~W83}H>xV1ikIeL^S)M8JS+q*lr*Y17yzqcll`!%kXLN=Yy# zH&c$9mD zb1WQK16EtCwJghqa>6@44Fej7E(oL-KwyJ3Vb<`LiiUcE<*IU~R#Iym0pg8yW#Kku z1J;GUh-0rnHO`v2)7kO|{qfPHzjOOw`|geH)BM|~tJPw;l7zF4 z7mm4FSZFE>;21@rZyZ!*QLHz0St@IY$C%H&fC)iMsj`)>H-=(N5#pS1&k4_hLAG^B zA`FO9%m^X?2%H13#%gIPGOCoSZ0e#e^QO!j-}l1E_kFK!+p3W@b^U}n=M%yaVh$s# zv5}x_r;*VF40X$okhOKBJR^3!<1r55hhkSs|tq@bygVc zEMt@tU01F5shny#gG@;Yg&ghrMwz+=1o_56T!|Z7dpQz^+vCMz8pVjy zpjuVS<<)S9#yj0;G7DKI+xPEH6)R`LyAl2Ti$`~F9q3K<&b#lFNH>idB*Dx1 z>__)+J^bdI!LWDd&hWEetG3BKFU{u1p~qznS6B1SyT4mqKWa>?BOF9T7El9zHEo49 z>}_xg%Ee{AS~c2$tE5wJeew^MmuH9s2a`L${OVWd5(gsN>W_wp$<;+=d5AH8b@I*k zKK{5f=t)i|4he3R_+;4QlV){rJ|s!*N%9{@|-)F1 zU(RR#0Q~Ogt6!ZjvZC9X$@bvZTf^s%XGL8%ZHofiJY5WSqKjF+J@zm`Z+}uA zo{mRhfdVS_kB)e=ZgwV5fAPh5$NSYU|A)(0h04)~pS(AG?<4Yj*{6~~FzNOTwP|

vaoD}{ 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�&Lf_rc>oF@^#Hg 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 z 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

OcS@;n_(Etr<@bugm@`r5(iAUAmUOI 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

2R3Pvg3$wZ@}s*+V6qNrHF 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 Date: Thu, 19 Aug 2021 14:53:18 +0530 Subject: [PATCH 03/20] update parameters --- tensorflow_gan/examples/esrgan/train.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/tensorflow_gan/examples/esrgan/train.py b/tensorflow_gan/examples/esrgan/train.py index 90a4b54..536481c 100644 --- a/tensorflow_gan/examples/esrgan/train.py +++ b/tensorflow_gan/examples/esrgan/train.py @@ -17,7 +17,7 @@ import train_lib import data_provider -flags.DEFINE_integer('batch_size', 4, +flags.DEFINE_integer('batch_size', 16, 'The number of images in each batch.') flags.DEFINE_string('model_dir', '/content/', 'Directory to save and load trained models') @@ -35,7 +35,7 @@ 'Directory to save DIV2K dataset.') flags.DEFINE_integer('print_steps', 1000, 'Steps at which values are displayed during training.') -flags.DEFINE_integer('total_steps', 1, +flags.DEFINE_integer('total_steps', 100000, 'The maximum number of steps for training.') flags.DEFINE_integer('decay_steps', 50000, 'Step at which learning rate is modified.') From 2ba84873c519f7393ca0de165ad205db52344313 Mon Sep 17 00:00:00 2001 From: Nived P A <62166124+nivedwho@users.noreply.github.com> Date: Thu, 19 Aug 2021 14:54:04 +0530 Subject: [PATCH 04/20] update parameters --- tensorflow_gan/examples/esrgan/eval.py | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/tensorflow_gan/examples/esrgan/eval.py b/tensorflow_gan/examples/esrgan/eval.py index b448552..2e1358a 100644 --- a/tensorflow_gan/examples/esrgan/eval.py +++ b/tensorflow_gan/examples/esrgan/eval.py @@ -19,7 +19,7 @@ import data_provider -flags.DEFINE_integer('batch_size', 2, +flags.DEFINE_integer('batch_size', 16, 'The number of images in each batch.') flags.DEFINE_integer('hr_dimension', 128, 'Dimension of a HR image.') @@ -29,9 +29,9 @@ 'Directory where the trained models are stored.') flags.DEFINE_string('data_dir', '/content/datasets', 'Directory where dataset is stored.') -flags.DEFINE_integer('num_steps', 2, +flags.DEFINE_integer('num_steps', 100, 'The number of steps for evaluation.') -flags.DEFINE_integer('num_inception_images', 2, +flags.DEFINE_integer('num_inception_images', 16, 'The number of images passed for evaluation at each step.') flags.DEFINE_string('image_dir', '/content/results', 'Directory to save generated images during evaluation.') @@ -54,4 +54,4 @@ def main(_): if __name__ == '__main__': logging.set_verbosity(logging.INFO) - app.run(main) \ No newline at end of file + app.run(main) From 042af794598a12815986cb09a8a7b874331d4c35 Mon Sep 17 00:00:00 2001 From: Nived P A <62166124+nivedwho@users.noreply.github.com> Date: Fri, 27 Aug 2021 12:02:13 +0530 Subject: [PATCH 05/20] Update Link --- tensorflow_gan/examples/esrgan/README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tensorflow_gan/examples/esrgan/README.md b/tensorflow_gan/examples/esrgan/README.md index 7d215c3..4917f8c 100644 --- a/tensorflow_gan/examples/esrgan/README.md +++ b/tensorflow_gan/examples/esrgan/README.md @@ -7,7 +7,7 @@ python esrgan/train.py ``` -The Notebook files for training ESRGAN on Google Colaboratory can be found [here](colab_notebooks) +The Notebook files for training ESRGAN on Google Colaboratory can be found [here](https://github.com/tensorflow/gan/blob/master/tensorflow_gan/examples/esrgan/colab_notebooks/) ### Description The ESRGAN model proposed in the paper [ESRGAN: Enhanced Super-Resolution Generative Adversarial Networks (Wang Xintao et al.)](https://arxiv.org/abs/1809.00219) performs the task of image super-resolution which is the process of reconstructing high resolution (HR) image from a given low resolution (LR) image. Here we have trained the ESRGAN model on the DIV2K dataset and the model is evaluated using TF-GAN. From 99affbe14c73f8660df47714abaff765c965b3b3 Mon Sep 17 00:00:00 2001 From: Nived P A <62166124+nivedwho@users.noreply.github.com> Date: Fri, 27 Aug 2021 12:44:30 +0530 Subject: [PATCH 06/20] Update data_provider.py Variable name changes, added 'name' argument for `get_div2k_data()`, used `AUTOTUNE` for parallel calls. --- .../examples/esrgan/data_provider.py | 28 +++++++++---------- 1 file changed, 14 insertions(+), 14 deletions(-) diff --git a/tensorflow_gan/examples/esrgan/data_provider.py b/tensorflow_gan/examples/esrgan/data_provider.py index f35d70c..6f4d9bf 100644 --- a/tensorflow_gan/examples/esrgan/data_provider.py +++ b/tensorflow_gan/examples/esrgan/data_provider.py @@ -13,7 +13,6 @@ # See the License for the specific language governing permissions and # limitations under the License. -import os import tensorflow as tf import tensorflow_datasets as tfds from tensorflow.python.data.experimental import AUTOTUNE @@ -21,26 +20,28 @@ def random_flip(lr_img, hr_img): """ Randomly flips LR and HR images for data augmentation.""" - rn = tf.random.uniform(shape=(), maxval=1) + random = tf.random.uniform(shape=(), maxval=1) - return tf.cond(rn < 0.5, + return tf.cond(random<0.5, lambda: (lr_img, hr_img), lambda: (tf.image.flip_left_right(lr_img), tf.image.flip_left_right(hr_img))) def random_rotate(lr_img, hr_img): """ Randomly rotates LR and HR images for data augmentation.""" - rn = tf.random.uniform(shape=(), maxval=4, dtype=tf.int32) - return tf.image.rot90(lr_img, rn), tf.image.rot90(hr_img, rn) + random = tf.random.uniform(shape=(), maxval=4, dtype=tf.int32) + return tf.image.rot90(lr_img, random), tf.image.rot90(hr_img, random) -def get_div2k_data(HParams, +def get_div2k_data(hparams, + name='div2k/bicubic_x4', mode='train', shuffle=True, repeat_count=None): """ Downloads and loads DIV2K dataset. Args: - HParams : For getting values for different parameters. + hparams : A named tuple to store different parameters. + name : Name of the dataset to be loaded using tfds. mode : Either 'train' or 'valid'. shuffle : Whether to shuffle the images in the dataset. repeat_count : Repetition of data during training. @@ -50,12 +51,11 @@ def get_div2k_data(HParams, Raises: TypeError : If the data directory(data_dir) is not specified. """ - bs = HParams.batch_size split = 'train' if mode == 'train' else 'validation' def scale(image, *args): - hr_size = HParams.hr_dimension - scale = HParams.scale + hr_size = hparams.hr_dimension + scale = hparams.scale hr_image = image hr_image = tf.image.resize(hr_image, [hr_size, hr_size]) @@ -66,18 +66,18 @@ def scale(image, *args): return lr_image, hr_image - dataset = (tfds.load('div2k/bicubic_x4', + dataset = (tfds.load(name=name, split=split, - data_dir=HParams.data_dir, + data_dir=hparams.data_dir, as_supervised=True) - .map(scale, num_parallel_calls=4) + .map(scale, num_parallel_calls=AUTOTUNE) .cache()) if shuffle: dataset = dataset.shuffle( buffer_size=10000, reshuffle_each_iteration=True) - dataset = dataset.batch(HParams.batch_size) + dataset = dataset.batch(hparams.batch_size) dataset = dataset.repeat(repeat_count) dataset = dataset.prefetch(buffer_size=AUTOTUNE) From cbfbc2dbeeb8a03cd96ef2756185099a9be9b714 Mon Sep 17 00:00:00 2001 From: Nived P A <62166124+nivedwho@users.noreply.github.com> Date: Fri, 27 Aug 2021 12:56:06 +0530 Subject: [PATCH 07/20] Update data_provider_test.py Variable name changes, removed unnecessary imports, moved `assertIsInstance()` --- .../examples/esrgan/data_provider_test.py | 18 ++++++------------ 1 file changed, 6 insertions(+), 12 deletions(-) diff --git a/tensorflow_gan/examples/esrgan/data_provider_test.py b/tensorflow_gan/examples/esrgan/data_provider_test.py index 1b4b067..46e473d 100644 --- a/tensorflow_gan/examples/esrgan/data_provider_test.py +++ b/tensorflow_gan/examples/esrgan/data_provider_test.py @@ -14,34 +14,28 @@ # limitations under the License. """Tests for tfgan.examples.esrgan.data_provider""" - -from __future__ import absolute_import -from __future__ import division -from __future__ import print_function - +import collections from absl.testing import absltest -import numpy as np import tensorflow as tf import data_provider -import collections -Params = collections.namedtuple('HParams', ['hr_dimension', + +hparams = collections.namedtuple('hparams', ['hr_dimension', 'scale', 'batch_size', 'data_dir']) class DataProviderTest(tf.test.TestCase, absltest.TestCase): - def setUp(self): super(DataProviderTest, self).setUp() - self.HParams = Params(256, 4, 32, '/content/') - self.dataset = data_provider.get_div2k_data(self.HParams) + self.hparams = hparams(256, 4, 32, '/content/') + self.dataset = data_provider.get_div2k_data(self.hparams) self.mock_lr = tf.random.normal([32, 64, 64, 3]) self.mock_hr = tf.random.normal([32, 256, 256, 3]) def test_dataset(self): + self.assertIsInstance(self.dataset, tf.data.Dataset) with self.cached_session() as sess: - self.assertIsInstance(self.dataset, tf.data.Dataset) lr_image, hr_image = next(iter(self.dataset)) sess.run(tf.compat.v1.global_variables_initializer()) From 339896fe209a243f2aec64b4c77957a875372b46 Mon Sep 17 00:00:00 2001 From: Nived P A <62166124+nivedwho@users.noreply.github.com> Date: Fri, 27 Aug 2021 13:58:46 +0530 Subject: [PATCH 08/20] Update eval_lib.py Variable name changes and fixed spacing --- tensorflow_gan/examples/esrgan/eval_lib.py | 22 +++++++++++----------- 1 file changed, 11 insertions(+), 11 deletions(-) diff --git a/tensorflow_gan/examples/esrgan/eval_lib.py b/tensorflow_gan/examples/esrgan/eval_lib.py index da28238..cbe7b18 100644 --- a/tensorflow_gan/examples/esrgan/eval_lib.py +++ b/tensorflow_gan/examples/esrgan/eval_lib.py @@ -13,17 +13,17 @@ # See the License for the specific language governing permissions and # limitations under the License. +import collections import tensorflow as tf from absl import logging import utils -import collections -HParams = collections.namedtuple('HParams', [ +hparams = collections.namedtuple('hparams', [ 'batch_size', 'hr_dimension', - 'scale', - 'model_dir', 'data_dir', - 'num_steps', 'num_inception_images', - 'image_dir', 'eval_real_images']) + 'scale', 'model_dir', + 'data_dir', 'num_steps', + 'num_inception_images', 'image_dir', + 'eval_real_images']) def evaluate(hparams, generator, data): """ Runs an evaluation loop and calculates the mean FID, @@ -38,24 +38,24 @@ def evaluate(hparams, generator, data): inc_metric = tf.keras.metrics.Mean() psnr_metric = tf.keras.metrics.Mean() step = 0 + for lr, hr in data.take(hparams.num_steps): step += 1 # Generate fake images for evaluating the model gen = generator(lr) - - if step % hparams.num_steps//10: + + if step%hparams.num_steps//10 == 0: utils.visualize_results(lr, gen, hr, image_dir=hparams.image_dir, step=step) - + # Compute Frechet Inception Distance. fid_score = utils.get_frechet_inception_distance( hr, gen, hparams.batch_size, hparams.num_inception_images) - fid_metric(fid_score) # Compute Inception Scores. @@ -74,4 +74,4 @@ def evaluate(hparams, generator, data): psnr_metric(psnr) logging.info('FID Score :{}\tInception Score :{}\tPSNR value :{}'.format( - fid_metric.result(), inc_metric.result(), psnr_metric.result())) \ No newline at end of file + fid_metric.result(), inc_metric.result(), psnr_metric.result())) From efb0250282435cd4f5bf56ea8f0914b8f0b6f84a Mon Sep 17 00:00:00 2001 From: Nived P A <62166124+nivedwho@users.noreply.github.com> Date: Fri, 27 Aug 2021 14:50:43 +0530 Subject: [PATCH 09/20] Update eval_test.py Variable name changes, removed unnecessary imports --- tensorflow_gan/examples/esrgan/eval_test.py | 23 ++++++++------------- 1 file changed, 9 insertions(+), 14 deletions(-) diff --git a/tensorflow_gan/examples/esrgan/eval_test.py b/tensorflow_gan/examples/esrgan/eval_test.py index 62a9a33..8f9b39b 100644 --- a/tensorflow_gan/examples/esrgan/eval_test.py +++ b/tensorflow_gan/examples/esrgan/eval_test.py @@ -15,27 +15,22 @@ """Tests for tfgan.examples.esrgan.eval""" -from __future__ import absolute_import -from __future__ import division -from __future__ import print_function - -from absl.testing import absltest -import os import collections import tensorflow as tf -import eval_lib, networks +import eval_lib +import networks -HParams = collections.namedtuple('HParams', [ +hparams = collections.namedtuple('hparams', [ 'num_steps', 'image_dir', 'batch_size', 'num_inception_images', 'eval_real_images', 'hr_dimension', 'scale', 'trunk_size']) class EvalTest(tf.test.TestCase): def setUp(self): - self.HParams = HParams(1, '/content/', - 2, 2, - True, 256, - 4, 11) + self.hparams = hparams(1, '/content/', + 2, 2, + True, 256, + 4, 11) d = tf.data.Dataset.from_tensor_slices(tf.random.normal([2, 256, 256, 3])) def lr(hr): @@ -45,10 +40,10 @@ def lr(hr): d = d.map(lr) d = d.batch(2) self.mock_dataset = d - self.generator = networks.generator_network(self.HParams) + self.generator = networks.generator_network(self.hparams) def test_eval(self): - self.assertIsNone(eval_lib.evaluate(self.HParams, + self.assertIsNone(eval_lib.evaluate(self.hparams, self.generator, self.mock_dataset)) From a5425f4c939b8a90b438ad2c61e125c78288816a Mon Sep 17 00:00:00 2001 From: Nived P A <62166124+nivedwho@users.noreply.github.com> Date: Fri, 27 Aug 2021 15:12:01 +0530 Subject: [PATCH 10/20] Update losses.py Added a TODO comment to remove the two loss functions once TF-GAN losses are updated. --- tensorflow_gan/examples/esrgan/losses.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/tensorflow_gan/examples/esrgan/losses.py b/tensorflow_gan/examples/esrgan/losses.py index 92a5487..a83cbaa 100644 --- a/tensorflow_gan/examples/esrgan/losses.py +++ b/tensorflow_gan/examples/esrgan/losses.py @@ -28,7 +28,7 @@ def pixel_loss(y_true, y_pred): y_pred = tf.cast(y_pred, tf.float32) return tf.reduce_mean(tf.reduce_mean(tf.abs(y_true - y_pred), axis=0)) - +# TODO(Nived): Remove this function once the relativitic losses are added to TF-GAN def ragan_generator_loss(d_real, d_fake, scope=None): @@ -60,7 +60,7 @@ def get_logits(x, y): return real_loss + fake_loss - +# TODO(Nived): Remove this function once the relativitic losses are added to TF-GAN def ragan_discriminator_loss(d_real, d_fake, scope=None): From 71f58ff83f8ee5f3e3769cc304310e2b7e0651b3 Mon Sep 17 00:00:00 2001 From: Nived P A <62166124+nivedwho@users.noreply.github.com> Date: Fri, 27 Aug 2021 15:13:25 +0530 Subject: [PATCH 11/20] Update losses_test.py Removed unnecessary imports --- tensorflow_gan/examples/esrgan/losses_test.py | 4 ---- 1 file changed, 4 deletions(-) diff --git a/tensorflow_gan/examples/esrgan/losses_test.py b/tensorflow_gan/examples/esrgan/losses_test.py index 588fa82..4285b7f 100644 --- a/tensorflow_gan/examples/esrgan/losses_test.py +++ b/tensorflow_gan/examples/esrgan/losses_test.py @@ -15,10 +15,6 @@ """Tests for tfgan.examples.esrgan.losses""" -from __future__ import absolute_import -from __future__ import division -from __future__ import print_function - from absl.testing import absltest import os From f96701eac51ba03cf8dc4009b2de2b063f423979 Mon Sep 17 00:00:00 2001 From: Nived P A <62166124+nivedwho@users.noreply.github.com> Date: Fri, 27 Aug 2021 15:36:16 +0530 Subject: [PATCH 12/20] Update networks.py Variable name changes and removed extra imports --- tensorflow_gan/examples/esrgan/networks.py | 135 ++++++++++----------- 1 file changed, 66 insertions(+), 69 deletions(-) diff --git a/tensorflow_gan/examples/esrgan/networks.py b/tensorflow_gan/examples/esrgan/networks.py index c30d87d..e50b8ce 100644 --- a/tensorflow_gan/examples/esrgan/networks.py +++ b/tensorflow_gan/examples/esrgan/networks.py @@ -15,11 +15,7 @@ import os import tensorflow as tf -from keras.models import Model -from keras.layers import Input, Add, Concatenate -from keras.layers import BatchNormalization, LeakyReLU, Conv2D, Dense, Conv2DTranspose -from keras.layers import Lambda, Dropout, Flatten - +from tensorflow.keras import layers """ Implementation of Generator (ESRGAN_G) and Discriminator (ESRGAN_D) models @@ -27,61 +23,62 @@ 'ESRGAN: Enhanced Super-Resolution Generative Adversarial Networks'. """ -def _conv_block(input, filters=32, activation=True): - h = Conv2D(filters, kernel_size=[3,3], bias_initializer="zeros", - strides=[1,1], padding='same')(input) +def _conv_block(input, filters, activation=True): + h = layers.Conv2D(filters, kernel_size=[3,3], + kernel_initializer="he_normal", bias_initializer="zeros", + strides=[1,1], padding='same', use_bias=True)(input) if activation: - h = LeakyReLU(0.2)(h) + h = layers.LeakyReLU(0.2)(h) return h def _conv_block_d(input, out_channel): - x = Conv2D(out_channel, 3,1, padding='same', use_bias=False)(input) - x = BatchNormalization(momentum=0.8)(x) - x = LeakyReLU(alpha=0.2)(x) + x = layers.Conv2D(out_channel, 3,1, padding='same', use_bias=False)(input) + x = layers.BatchNormalization(momentum=0.8)(x) + x = layers.LeakyReLU(alpha=0.2)(x) - x = Conv2D(out_channel, 4,2, padding='same', use_bias=False)(x) - x = BatchNormalization(momentum=0.8)(x) - x = LeakyReLU(alpha=0.2)(x) + x = layers.Conv2D(out_channel, 4,2, padding='same', use_bias=False)(x) + x = layers.BatchNormalization(momentum=0.8)(x) + x = layers.LeakyReLU(alpha=0.2)(x) return x def dense_block(input): - h1 = _conv_block(input) - h1 = Concatenate()([input, h1]) - - h2 = _conv_block(h1) - h2 = Concatenate()([input, h1, h2]) - - h3 = _conv_block(h2) - h3 = Concatenate()([input, h1, h2, h3]) + h1 = _conv_block(input, 32) + h1 = layers.Concatenate()([input, h1]) - h4 = _conv_block(h3) - h4 = Concatenate()([input, h1, h2, h3, h4]) + h2 = _conv_block(h1, 32) + h2 = layers.Concatenate()([input, h1, h2]) - h5 = _conv_block(h4, activation=False) + h3 = _conv_block(h2, 32) + h3 = layers.Concatenate()([input, h1, h2, h3]) - h5 = Lambda(lambda x: x * 0.2)(h5) - h = Add()([h5, input]) + h4 = _conv_block(h3, 32) + h4 = layers.Concatenate()([input, h1, h2, h3, h4]) + h5 = _conv_block(h4, 32, activation=False) + + h5 = layers.Lambda(lambda x: x * 0.2)(h5) + h = layers.Add()([h5, input]) + return h -def rrdb_block(input): +def rrdb(input): h = dense_block(input) h = dense_block(h) h = dense_block(h) - h = Lambda(lambda x: x * 0.2)(h) - out = Add()([h, input]) + h = layers.Lambda(lambda x:x * 0.2)(h) + out = layers.Add()([h, input]) return out -def upsample(x, filters, use_bias=True): - x = Conv2DTranspose(filters, kernel_size=[3, 3], - strides=[2, 2], padding='same', - use_bias=use_bias)(x) - x = LeakyReLU(alpha=0.2)(x) +def upsample(x, filters): + x = layers.Conv2DTranspose(filters, kernel_size=3, + strides=2, padding='same', + use_bias = True)(x) + x = layers.LeakyReLU(alpha=0.2)(x) return x -def generator_network(HParams, - num_filters=32, - out_channels=3): +def generator_network(hparams, + num_filters=32, + out_channels=3): """ The Generator network for ESRGAN consisting of Residual in Residual Block as the basic building unit. @@ -97,38 +94,38 @@ def generator_network(HParams, inputs -> Batch of tensors representing LR images. outputs -> Batch of generated HR images. """ - lr_input = Input(shape=(HParams.hr_dimension//HParams.scale, - HParams.hr_dimension//HParams.scale, 3)) + lr_input = layers.Input(shape=(hparams.hr_dimension//hparams.scale, + hparams.hr_dimension//hparams.scale, 3)) - x = Conv2D(num_filters, kernel_size=[3, 3], strides=[1, 1], - padding='same', use_bias=True)(lr_input) - x = LeakyReLU(0.2)(x) + x = layers.Conv2D(num_filters, kernel_size=[3, 3], strides=[1, 1], + padding='same', use_bias=True)(lr_input) + x = layers.LeakyReLU(0.2)(x) ref = x - for _ in range(HParams.trunk_size): - x = rrdb_block(x) + for _ in range(hparams.trunk_size): + x = rrdb(x) - x = Conv2D(num_filters, kernel_size=[3, 3], strides=[1, 1], + x = layers.Conv2D(num_filters, kernel_size=[3, 3], strides=[1, 1], padding='same', use_bias=True)(x) - x = Add()([x, ref]) + x = layers.Add()([x, ref]) x = upsample(x, num_filters) x = upsample(x, num_filters) - x = Conv2D(num_filters, kernel_size=[3, 3], strides=[1, 1], - padding='same', use_bias=True)(x) - x = LeakyReLU(0.2)(x) - hr_output = Conv2D(out_channels, kernel_size=[3, 3], strides=[1, 1], - padding='same', use_bias=True)(x) + x = layers.Conv2D(num_filters, kernel_size=[3, 3], strides=[1, 1], + padding='same', use_bias=True)(x) + x = layers.LeakyReLU(0.2)(x) + hr_output = layers.Conv2D(out_channels, kernel_size=[3, 3], strides=[1, 1], + padding='same', use_bias=True)(x) - model = Model(inputs=lr_input, outputs=hr_output) + model = tf.keras.models.Model(inputs=lr_input, outputs=hr_output) return model -def discriminator_network(HParams, - num_filters=64, - training=True): +def discriminator_network(hparams, + num_filters=64, + training=True): """ The discriminator network for ESRGAN. @@ -140,24 +137,24 @@ def discriminator_network(HParams, inputs -> Batch of tensors representing HR images. outputs -> Predictions for batch of input images. """ - img = Input(shape=(HParams.hr_dimension, HParams.hr_dimension, 3)) + img = layers.Input(shape=(hparams.hr_dimension, hparams.hr_dimension, 3)) - x = Conv2D(num_filters, [3,3], 1, padding='same', use_bias=False)(img) - x = BatchNormalization()(x) - x = LeakyReLU(alpha=0.2)(x) + x = layers.Conv2D(num_filters, [3,3], 1, padding='same', use_bias=False)(img) + x = layers.BatchNormalization()(x) + x = layers.LeakyReLU(alpha=0.2)(x) - x = Conv2D(num_filters, [3,3], 2, padding='same', use_bias=False)(x) - x = BatchNormalization()(x) - x = LeakyReLU(alpha=0.2)(x) + x = layers.Conv2D(num_filters, [3,3], 2, padding='same', use_bias=False)(x) + x = layers.BatchNormalization()(x) + x = layers.LeakyReLU(alpha=0.2)(x) x = _conv_block_d(x, num_filters *2) x = _conv_block_d(x, num_filters *4) x = _conv_block_d(x, num_filters *8) - x = Flatten()(x) - x = Dense(100)(x) - x = LeakyReLU(alpha=0.2)(x) - x = Dense(1)(x) + x = layers.Flatten()(x) + x = layers.Dense(100)(x) + x = layers.LeakyReLU(alpha=0.2)(x) + x = layers.Dense(1)(x) - model = Model(inputs=img, outputs=x) + model = tf.keras.models.Model(inputs = img, outputs = x) return model From 6f33f600ef8eb9ca7494697090d726e17e7c7f99 Mon Sep 17 00:00:00 2001 From: Nived P A <62166124+nivedwho@users.noreply.github.com> Date: Fri, 27 Aug 2021 16:17:49 +0530 Subject: [PATCH 13/20] Update networks_test.py Variable name changes and removed unnecessary imports. --- tensorflow_gan/examples/esrgan/networks_test.py | 12 ++++-------- 1 file changed, 4 insertions(+), 8 deletions(-) diff --git a/tensorflow_gan/examples/esrgan/networks_test.py b/tensorflow_gan/examples/esrgan/networks_test.py index 9c41636..48777e7 100644 --- a/tensorflow_gan/examples/esrgan/networks_test.py +++ b/tensorflow_gan/examples/esrgan/networks_test.py @@ -15,22 +15,18 @@ """Tests for tfgan.examples.esrgan.networks""" -from __future__ import absolute_import -from __future__ import division -from __future__ import print_function - import tensorflow as tf import networks import collections -Params = collections.namedtuple('HParams', ['hr_dimension', +hparams = collections.namedtuple('hparams', ['hr_dimension', 'scale', 'trunk_size']) class NetworksTest(tf.test.TestCase): def setUp(self): - self.HParams = Params(256, 4, 11) - self.generator = networks.generator_network(self.HParams) - self.discriminator = networks.discriminator_network(self.HParams) + self.hparams = hparams(256, 4, 11) + self.generator = networks.generator_network(self.hparams) + self.discriminator = networks.discriminator_network(self.hparams) def test_network_type(self): """ Verifies that the models are of keras.Model type """ From cd2b712d32cfc888cb193d67c8b85c0f7ddfd518 Mon Sep 17 00:00:00 2001 From: Nived P A <62166124+nivedwho@users.noreply.github.com> Date: Fri, 27 Aug 2021 17:57:25 +0530 Subject: [PATCH 14/20] Update train_lib.py Variable name changes, removed `list.pop()`, fixed imports and added default arguments for `_get_optimizer()` --- tensorflow_gan/examples/esrgan/train_lib.py | 154 ++++++++++---------- 1 file changed, 74 insertions(+), 80 deletions(-) diff --git a/tensorflow_gan/examples/esrgan/train_lib.py b/tensorflow_gan/examples/esrgan/train_lib.py index fdf0d3b..03869a1 100644 --- a/tensorflow_gan/examples/esrgan/train_lib.py +++ b/tensorflow_gan/examples/esrgan/train_lib.py @@ -21,11 +21,12 @@ import collections import os from absl import logging -from networks import generator_network, discriminator_network -from losses import pixel_loss, vgg_loss, ragan_generator_loss, ragan_discriminator_loss -from utils import preprocess_input, get_psnr, visualize_results, network_interpolation -HParams = collections.namedtuple('HParams', [ +import networks +import losses +import utils + +hparams = collections.namedtuple('hparams', [ 'batch_size', 'scale', 'model_dir', 'phase_1', 'phase_2', 'hr_dimension', @@ -37,12 +38,12 @@ 'loss_type', 'lambda_', 'eta', 'image_dir']) -def pretrain_generator(HParams, data): +def pretrain_generator(hparams, data): """ Pre-trains the generator network with pixel-loss as proposed in the paper and saves the network inside the model directory specified. Args: - HParams : Training parameters as proposed in the paper. + hparams : Training parameters as proposed in the paper. data : Dataset consisting of LR and HR image pairs. """ @@ -51,15 +52,15 @@ def pretrain_generator(HParams, data): psnr_metric = tf.keras.metrics.Mean() # If phase_1 training is done, load that generator model. - if HParams.phase_1: - generator = tf.keras.load_model(HParams.model_dir + '/Phase_1/generator/') + if hparams.phase_1: + generator = tf.keras.load_model(hparams.model_dir + '/Phase_1/generator/') # If pre-trained model is not available, start training from the beginning else: - generator = generator_network(HParams) + generator = networks.generator_network(hparams) logging.info("Starting Phase-1 training of generator using only pixel loss function.") - G_optimizer = _get_optimizer() + g_optimizer = _get_optimizer() def train_step(image_lr, image_hr): """ Calculates the L1 Loss and gradients at each step, and updates the @@ -74,16 +75,16 @@ def train_step(image_lr, image_hr): with tf.GradientTape() as tape: fake = generator(image_lr) - gen_loss = pixel_loss(image_hr, fake) * (1.0 / HParams.batch_size) - psnr = get_psnr(image_hr, fake) + gen_loss = losses.pixel_loss(image_hr, fake) * (1.0 / hparams.batch_size) + psnr = utils.get_psnr(image_hr, fake) gradient = tape.gradient(gen_loss, generator.trainable_variables) - G_optimizer.apply_gradients(zip(gradient, generator.trainable_variables)) + g_optimizer.apply_gradients(zip(gradient, generator.trainable_variables)) return psnr, gen_loss step = 0 - for lr, hr in data.take(HParams.total_steps): + for lr, hr in data.take(hparams.total_steps): step += 1 lr = tf.cast(lr, tf.float32) hr = tf.cast(hr, tf.float32) @@ -94,60 +95,56 @@ def train_step(image_lr, image_hr): metric(gen_loss) psnr_metric(psnr) - if step % HParams.print_steps == 0: + if step % hparams.print_steps == 0: logging.info("Step: {}\tGenerator Loss: {}\tPSNR: {}".format( step, metric.result(), psnr_metric.result())) # Modify the learning rate as mentioned in the paper. - if step % HParams.decay_steps == 0: - G_optimizer.learning_rate.assign( - G_optimizer.learning_rate * HParams.decay_factor) + if step % hparams.decay_steps == 0: + g_optimizer.learning_rate.assign( + g_optimizer.learning_rate * hparams.decay_factor) # Save the generator model inside model_dir. - os.makedirs(HParams.model_dir + '/Phase_1/generator', exist_ok=True) - generator.save(HParams.model_dir + '/Phase_1/generator') + os.makedirs(hparams.model_dir + '/Phase_1/generator', exist_ok=True) + generator.save(hparams.model_dir + '/Phase_1/generator') logging.info("Saved pre-trained generator network succesfully!") -def train_esrgan(HParams, data): +def train_esrgan(hparams, data): """Loads the pre-trained generator model and trains the ESRGAN network using L1 Loss, Perceptual loss and RaGAN loss function. Args: - HParams : Training parameters as proposed in the paper. + hparams : Training parameters as proposed in the paper. data : Dataset consisting of LR and HR image pairs. """ # If the phase 2 training is done,load thd trained networks. - if HParams.phase_2: - generator = tf.keras.models.load_model(HParams.model_dir + + if hparams.phase_2: + generator = tf.keras.models.load_model(hparams.model_dir + 'Phase_2/generator/') - discriminator = tf.keras.models.load_model(HParams.model_dir + + discriminator = tf.keras.models.load_model(hparams.model_dir + 'Phase_2/discriminator/') # If Phase 2 training is not done, then load the pre-trained generator model. else: try: - generator = tf.keras.models.load_model(HParams.model_dir + + generator = tf.keras.models.load_model(hparams.model_dir + '/Phase_1/generator') except: raise FileNotFoundError('Pre-trained Generator model not found!') - discriminator = discriminator_network(HParams) + discriminator = networks.discriminator_network(hparams) logging.info("Starting Phase-2 training of ESRGAN") # Generator learning rate is set as 1 x 10^-4. - G_optimizer = _get_optimizer(lr=HParams.init_lr) - D_optimizer = _get_optimizer() - - # Define RaGAN loss for generator and discriminator networks. - #ra_gen = relativistic_avg_loss_g(discriminator) - #ra_disc = relativistic_avg_loss_d(discriminator) + g_optimizer = _get_optimizer(lr=hparams.init_lr) + d_optimizer = _get_optimizer() # Define the Perceptual loss function and # pass 'imagenet' as the weight for the VGG-19 network. - perceptual_loss = vgg_loss( + perceptual_loss = losses.vgg_loss( weight="imagenet", - input_shape=[HParams.hr_dimension, HParams.hr_dimension, 3]) + input_shape=[hparams.hr_dimension, hparams.hr_dimension, 3]) gen_metric = tf.keras.metrics.Mean() disc_metric = tf.keras.metrics.Mean() @@ -166,35 +163,34 @@ def train_step(image_lr, image_hr, step): with tf.GradientTape() as gen_tape, tf.GradientTape() as disc_tape: gen = generator(image_lr) - fake = preprocess_input(gen) - image_lr = preprocess_input(image_lr) - image_hr = preprocess_input(image_hr) + fake = utils.preprocess_input(gen) + image_lr = utils.preprocess_input(image_lr) + image_hr = utils.preprocess_input(image_hr) percep_loss = tf.reduce_mean(perceptual_loss(image_hr, fake)) - l1_loss = pixel_loss(image_hr, fake) - - loss_RaG = ragan_generator_loss(discriminator(image_hr), - discriminator(fake)) - disc_loss = ragan_discriminator_loss(discriminator(image_hr), - discriminator(fake)) - #loss_RaG = ra_gen(image_hr, fake) - #disc_loss = ra_disc(image_hr, fake) + l1_loss = losses.pixel_loss(image_hr, fake) - gen_loss = percep_loss + HParams.lambda_ * loss_RaG + HParams.eta * l1_loss + # TODO(Nived): Replace these functions once TF-GAN losses are updated. + loss_RaG = losses.ragan_generator_loss(discriminator(image_hr), + discriminator(fake)) + disc_loss = losses.ragan_discriminator_loss(discriminator(image_hr), + discriminator(fake)) - gen_loss = gen_loss * (1.0 / HParams.batch_size) - disc_loss = disc_loss * (1.0 / HParams.batch_size) - psnr = get_psnr(image_hr, fake) + gen_loss = percep_loss + hparams.lambda_ * loss_RaG + hparams.eta * l1_loss + + gen_loss = gen_loss * (1.0 / hparams.batch_size) + disc_loss = disc_loss * (1.0 / hparams.batch_size) + psnr = utils.get_psnr(image_hr, fake) disc_grad = disc_tape.gradient(disc_loss, discriminator.trainable_variables) - D_optimizer.apply_gradients(zip(disc_grad, + d_optimizer.apply_gradients(zip(disc_grad, discriminator.trainable_variables)) gen_grad = gen_tape.gradient(gen_loss, generator.trainable_variables) - G_optimizer.apply_gradients(zip(gen_grad, + g_optimizer.apply_gradients(zip(gen_grad, generator.trainable_variables)) return gen_loss, disc_loss, psnr @@ -209,17 +205,18 @@ def val_step(image_lr, image_hr, step): file. """ fake=generator(image_lr) - visualize_results(image_lr, - fake, - image_hr, - HParams.image_dir, - step=step) + utils.visualize_results(image_lr, + fake, + image_hr, + hparams.image_dir, + step=step) step = 0 # Modify learning rate at each of these steps decay_list = [50000, 100000, 200000, 300000] + index=0 - for lr, hr in data.take(HParams.total_steps): + for lr, hr in data.take(hparams.total_steps): step += 1 lr = tf.cast(lr, tf.float32) hr = tf.cast(hr, tf.float32) @@ -230,46 +227,43 @@ def val_step(image_lr, image_hr, step): disc_metric(disc_loss) psnr_metric(psnr) - if step % HParams.print_steps == 0: + if step % hparams.print_steps == 0: logging.info("Step: {}\tGenerator Loss: {}\tDiscriminator: {}\tPSNR: {}" .format(step, gen_metric.result(), disc_metric.result(), psnr_metric.result())) - val_step(lr, hr, step) # Modify the learning rate as mentioned in the paper. - if step >= decay_list[0]: - G_optimizer.learning_rate.assign( - G_optimizer.learning_rate * HParams.decay_factor) - - D_optimizer.learning_rate.assign( - D_optimizer.learning_rate * HParams.decay_factor) - - decay_list.pop(0) + if step >= decay_list[index]: + g_optimizer.learning_rate.assign( + g_optimizer.learning_rate * hparams.decay_factor) + d_optimizer.learning_rate.assign( + d_optimizer.learning_rate * hparams.decay_factor) + + index+=1 + # Save the generator model inside model_dir. - os.makedirs(HParams.model_dir + '/Phase_2/generator', exist_ok=True) - generator.save(HParams.model_dir + '/Phase_2/generator') + os.makedirs(hparams.model_dir + '/Phase_2/generator', exist_ok=True) + generator.save(hparams.model_dir + '/Phase_2/generator') logging.info("Saved trained ESRGAN generator succesfully!") - interpolated_generator = network_interpolation( - phase_1_path=HParams.model_dir + '/Phase_1/generator', - phase_2_path=HParams.model_dir + '/Phase_2/generator') + interpolated_generator = utils.network_interpolation( + phase_1_path=hparams.model_dir + '/Phase_1/generator', + phase_2_path=hparams.model_dir + '/Phase_2/generator') #Save interpolated generator - os.makedirs(HParams.model_dir + os.makedirs(hparams.model_dir + '/Phase_2/interpolated_generator', exist_ok=True) - interpolated_generator.save(HParams.model_dir + interpolated_generator.save(hparams.model_dir + '/Phase_2/interpolated_generator') logging.info("Saved interpolated generator network succesfully!") -def _get_optimizer(lr=0.0002): +def _get_optimizer(lr=0.0002, beta_1=0.9, beta_2=0.99): """Returns the Adam optimizer with the specified learning rate.""" optimizer = tf.optimizers.Adam( learning_rate=lr, - beta_1=0.9, - beta_2=0.99 - ) + beta_1=beta_1, + beta_2=beta_2) return optimizer - From f803538a1debfe7264a70a7ea0f783f990926543 Mon Sep 17 00:00:00 2001 From: Nived P A <62166124+nivedwho@users.noreply.github.com> Date: Fri, 27 Aug 2021 19:05:41 +0530 Subject: [PATCH 15/20] Update train_test.py Removed unnecessary imports --- tensorflow_gan/examples/esrgan/train_test.py | 9 ++------- 1 file changed, 2 insertions(+), 7 deletions(-) diff --git a/tensorflow_gan/examples/esrgan/train_test.py b/tensorflow_gan/examples/esrgan/train_test.py index ecea0b7..1b9b3bc 100644 --- a/tensorflow_gan/examples/esrgan/train_test.py +++ b/tensorflow_gan/examples/esrgan/train_test.py @@ -15,19 +15,14 @@ """Tests for tfgan.examples.esrgan.train""" -from __future__ import absolute_import -from __future__ import division -from __future__ import print_function - from absl.testing import absltest -import os import collections import tensorflow as tf import train_lib mock = tf.compat.v1.test.mock -HParams = collections.namedtuple('HParams', [ +hparams = collections.namedtuple('hparams', [ 'batch_size', 'scale', 'model_dir', 'phase_1', 'phase_2', 'hr_dimension', @@ -41,7 +36,7 @@ class TrainTest(tf.test.TestCase): def setUp(self): - self.HParams = HParams(32, 4, '/content/', + self.hparams = hparams(32, 4, '/content/', False, False, 256, '/content/', 1, 11, 1, 1, 0.5, 0.0001, 0.5, 0.001, 0.00005, From 391920db103bec7d579fd00c129d1920e69c1a09 Mon Sep 17 00:00:00 2001 From: Nived P A <62166124+nivedwho@users.noreply.github.com> Date: Fri, 27 Aug 2021 22:46:36 +0530 Subject: [PATCH 16/20] Update utils.py Added explanation for `preprocess_input()` --- tensorflow_gan/examples/esrgan/utils.py | 19 ++++++++++++------- 1 file changed, 12 insertions(+), 7 deletions(-) diff --git a/tensorflow_gan/examples/esrgan/utils.py b/tensorflow_gan/examples/esrgan/utils.py index ff8adf8..28a1a17 100644 --- a/tensorflow_gan/examples/esrgan/utils.py +++ b/tensorflow_gan/examples/esrgan/utils.py @@ -22,8 +22,13 @@ def preprocess_input(image): - """ Preprocessing of images done before calculating loss - functions during training.""" + """ Input images are preprocessed by subtracting the dataset mean. + Since the VGG-19 network used here to extract features, is pretrained + on ImageNet dataset, its mean value (103.939, 116.779, 123.68) is subtracted + from the input images. + This ensures that each feature will have a similar range and the gradients + calculated during training are stable. + """ image = image[..., ::-1] mean = -tf.constant([103.939, 116.779, 123.68]) return tf.nn.bias_add(image, mean) @@ -32,6 +37,7 @@ def preprocess_input(image): def visualize_results(image_lr, generated, image_hr, + size = 256, image_dir='', step=0, train=True): @@ -40,15 +46,14 @@ def visualize_results(image_lr, saves the results as a .png image. Args: - image_lr : batch of tensors representing LR images. - generated : batch of tensors representing generated images. - image_hr : batch of tensors representing HR images. + image_lr : Batch of tensors representing LR images. + generated : Batch of tensors representing generated images. + image_hr : Batch of tensors representing HR images. + size : Size to which all images are resized for visualization. image_dir : Directory to save the results. step : Number of steps completed, for naming purposes. train : Training or Validation. """ - # Resizing all images to 256x256 just for visualization - size = 256 resized_lr = tf.image.resize( image_lr, [size, size], method=tf.image.ResizeMethod.BILINEAR) resized_gen = tf.image.resize( From bdd33c69c4c6a53bc9b644785d1c45df130d35c7 Mon Sep 17 00:00:00 2001 From: Nived P A <62166124+nivedwho@users.noreply.github.com> Date: Fri, 27 Aug 2021 22:49:06 +0530 Subject: [PATCH 17/20] Update utils_test.py Removed unnecessary imports --- tensorflow_gan/examples/esrgan/utils_test.py | 8 ++------ 1 file changed, 2 insertions(+), 6 deletions(-) diff --git a/tensorflow_gan/examples/esrgan/utils_test.py b/tensorflow_gan/examples/esrgan/utils_test.py index bad0034..c67c8b4 100644 --- a/tensorflow_gan/examples/esrgan/utils_test.py +++ b/tensorflow_gan/examples/esrgan/utils_test.py @@ -15,16 +15,12 @@ """Tests for tfgan.examples.esrgan.utils""" -from __future__ import absolute_import -from __future__ import division -from __future__ import print_function - from absl.testing import absltest -import os import collections import tensorflow as tf -import utils, networks +import utils +import networks Params = collections.namedtuple('HParams', ['hr_dimension', From e00963c1bf16733799e2ecd4e52a8dfefc701fcc Mon Sep 17 00:00:00 2001 From: supertramp2 Date: Mon, 30 Aug 2021 03:05:52 +0530 Subject: [PATCH 18/20] Update docstrings --- .../examples/esrgan/data_provider.py | 8 ++-- .../examples/esrgan/data_provider_test.py | 13 +++--- tensorflow_gan/examples/esrgan/eval.py | 6 ++- tensorflow_gan/examples/esrgan/eval_lib.py | 8 ++-- tensorflow_gan/examples/esrgan/eval_test.py | 8 ++-- tensorflow_gan/examples/esrgan/losses.py | 34 +++++++-------- tensorflow_gan/examples/esrgan/losses_test.py | 5 ++- tensorflow_gan/examples/esrgan/networks.py | 43 +++++++++---------- .../examples/esrgan/networks_test.py | 18 ++++---- tensorflow_gan/examples/esrgan/train.py | 2 + tensorflow_gan/examples/esrgan/train_lib.py | 41 ++++++++---------- tensorflow_gan/examples/esrgan/train_test.py | 37 ++++++---------- tensorflow_gan/examples/esrgan/utils.py | 30 +++++++------ tensorflow_gan/examples/esrgan/utils_test.py | 28 ++++++------ 14 files changed, 137 insertions(+), 144 deletions(-) diff --git a/tensorflow_gan/examples/esrgan/data_provider.py b/tensorflow_gan/examples/esrgan/data_provider.py index 6f4d9bf..cd54962 100644 --- a/tensorflow_gan/examples/esrgan/data_provider.py +++ b/tensorflow_gan/examples/esrgan/data_provider.py @@ -13,13 +13,15 @@ # See the License for the specific language governing permissions and # limitations under the License. +"""Contains code for loading DIV2K dataset.""" + import tensorflow as tf import tensorflow_datasets as tfds from tensorflow.python.data.experimental import AUTOTUNE def random_flip(lr_img, hr_img): - """ Randomly flips LR and HR images for data augmentation.""" + """Randomly flips LR and HR images for data augmentation.""" random = tf.random.uniform(shape=(), maxval=1) return tf.cond(random<0.5, @@ -28,7 +30,7 @@ def random_flip(lr_img, hr_img): tf.image.flip_left_right(hr_img))) def random_rotate(lr_img, hr_img): - """ Randomly rotates LR and HR images for data augmentation.""" + """Randomly rotates LR and HR images for data augmentation.""" random = tf.random.uniform(shape=(), maxval=4, dtype=tf.int32) return tf.image.rot90(lr_img, random), tf.image.rot90(hr_img, random) @@ -38,7 +40,7 @@ def get_div2k_data(hparams, mode='train', shuffle=True, repeat_count=None): - """ Downloads and loads DIV2K dataset. + """Downloads and loads DIV2K dataset. Args: hparams : A named tuple to store different parameters. name : Name of the dataset to be loaded using tfds. diff --git a/tensorflow_gan/examples/esrgan/data_provider_test.py b/tensorflow_gan/examples/esrgan/data_provider_test.py index 46e473d..3186b3f 100644 --- a/tensorflow_gan/examples/esrgan/data_provider_test.py +++ b/tensorflow_gan/examples/esrgan/data_provider_test.py @@ -13,22 +13,23 @@ # See the License for the specific language governing permissions and # limitations under the License. -"""Tests for tfgan.examples.esrgan.data_provider""" +"""Tests for tfgan.examples.esrgan.data_provider.""" + import collections from absl.testing import absltest import tensorflow as tf import data_provider -hparams = collections.namedtuple('hparams', ['hr_dimension', - 'scale', - 'batch_size', - 'data_dir']) +HParams = collections.namedtuple('HParams', ['hr_dimension', + 'scale', + 'batch_size', + 'data_dir']) class DataProviderTest(tf.test.TestCase, absltest.TestCase): def setUp(self): super(DataProviderTest, self).setUp() - self.hparams = hparams(256, 4, 32, '/content/') + self.hparams = HParams(256, 4, 32, '/content/') self.dataset = data_provider.get_div2k_data(self.hparams) self.mock_lr = tf.random.normal([32, 64, 64, 3]) self.mock_hr = tf.random.normal([32, 256, 256, 3]) diff --git a/tensorflow_gan/examples/esrgan/eval.py b/tensorflow_gan/examples/esrgan/eval.py index 2e1358a..768c15b 100644 --- a/tensorflow_gan/examples/esrgan/eval.py +++ b/tensorflow_gan/examples/esrgan/eval.py @@ -13,6 +13,8 @@ # See the License for the specific language governing permissions and # limitations under the License. +"""Contains code for evaluating ESRGAN model.""" + from absl import flags, logging, app import tensorflow as tf import eval_lib @@ -43,8 +45,8 @@ def main(_): hparams = eval_lib.HParams(FLAGS.batch_size, FLAGS.hr_dimension, FLAGS.scale, FLAGS.model_dir, - FLAGS.data_dir,FLAGS.num_steps, - FLAGS.num_inception_images,FLAGS.image_dir, + FLAGS.data_dir, FLAGS.num_steps, + FLAGS.num_inception_images, FLAGS.image_dir, FLAGS.eval_real_images) generator = tf.keras.models.load_model(FLAGS.model_dir + diff --git a/tensorflow_gan/examples/esrgan/eval_lib.py b/tensorflow_gan/examples/esrgan/eval_lib.py index cbe7b18..2093f40 100644 --- a/tensorflow_gan/examples/esrgan/eval_lib.py +++ b/tensorflow_gan/examples/esrgan/eval_lib.py @@ -13,12 +13,14 @@ # See the License for the specific language governing permissions and # limitations under the License. +"""Contains code for evaluating ESRGAN model.""" + import collections import tensorflow as tf from absl import logging import utils -hparams = collections.namedtuple('hparams', [ +HParams = collections.namedtuple('HParams', [ 'batch_size', 'hr_dimension', 'scale', 'model_dir', 'data_dir', 'num_steps', @@ -26,8 +28,8 @@ 'eval_real_images']) def evaluate(hparams, generator, data): - """ Runs an evaluation loop and calculates the mean FID, - Inception and PSNR scores observed on the validation dataset. + """Runs an evaluation loop and calculates the mean FID, + Inception and PSNR scores observed on the validation dataset. Args: hparams: Parameters for evaluation. diff --git a/tensorflow_gan/examples/esrgan/eval_test.py b/tensorflow_gan/examples/esrgan/eval_test.py index 8f9b39b..b68fadf 100644 --- a/tensorflow_gan/examples/esrgan/eval_test.py +++ b/tensorflow_gan/examples/esrgan/eval_test.py @@ -21,13 +21,13 @@ import eval_lib import networks -hparams = collections.namedtuple('hparams', [ - 'num_steps', 'image_dir', 'batch_size', 'num_inception_images', - 'eval_real_images', 'hr_dimension', 'scale', 'trunk_size']) +HParams = collections.namedtuple('HParams', [ + 'num_steps', 'image_dir', 'batch_size', 'num_inception_images', + 'eval_real_images', 'hr_dimension', 'scale', 'trunk_size']) class EvalTest(tf.test.TestCase): def setUp(self): - self.hparams = hparams(1, '/content/', + self.hparams = HParams(1, '/content/', 2, 2, True, 256, 4, 11) diff --git a/tensorflow_gan/examples/esrgan/losses.py b/tensorflow_gan/examples/esrgan/losses.py index a83cbaa..598b38d 100644 --- a/tensorflow_gan/examples/esrgan/losses.py +++ b/tensorflow_gan/examples/esrgan/losses.py @@ -13,11 +13,12 @@ # See the License for the specific language governing permissions and # limitations under the License. -import os +"""Loss functions for training ESRGAN model.""" + import tensorflow as tf def pixel_loss(y_true, y_pred): - """ To calculate the L1 Loss. + """To calculate the L1 Loss. Args : y_true : Original HR image present in the dataset. y_pred : Image generated by the generator network. @@ -32,8 +33,8 @@ def pixel_loss(y_true, y_pred): def ragan_generator_loss(d_real, d_fake, scope=None): - """ To calculate the adversarial loss for generator - network using a relativistic discriminator. + """To calculate the adversarial loss for generator + network using a relativistic discriminator. Args: d_real: Discriminator output on real data. @@ -43,10 +44,9 @@ def ragan_generator_loss(d_real, Returns: Adversarial loss for generator. """ - with tf.compat.v1.name_scope( - scope, - 'relativistic_avg_generator_loss', - values=[d_real, d_fake]): + with tf.compat.v1.name_scope(scope, + 'relativistic_avg_generator_loss', + values=[d_real, d_fake]): def get_logits(x, y): return x - tf.reduce_mean(y) @@ -64,21 +64,21 @@ def get_logits(x, y): def ragan_discriminator_loss(d_real, d_fake, scope=None): - """ To calculate the adversarial loss for discriminator - network using a relativistic discriminator. + """To calculate the adversarial loss for discriminator + network using a relativistic discriminator. Args: d_real: Discriminator output on real data. d_fake: Discriminator output on generated data. Expected to be in the range of (-inf, inf). scope: The scope for the operations performed in computing the loss. + Returns: Adversarial loss for discriminator. """ - with tf.compat.v1.name_scope( - scope, - 'relativistic_avg_discriminator_loss', - values=[d_real, d_fake]): + with tf.compat.v1.name_scope(scope, + 'relativistic_avg_discriminator_loss', + values=[d_real, d_fake]): def get_logits(x, y): return x - tf.reduce_mean(y) @@ -86,15 +86,15 @@ def get_logits(x, y): fake_logits = get_logits(d_fake, d_real) real_loss = tf.reduce_mean(tf.nn.sigmoid_cross_entropy_with_logits( - labels=tf.ones_like(real_logits), logits=real_logits)) + labels=tf.ones_like(real_logits), logits=real_logits)) fake_loss = tf.reduce_mean(tf.nn.sigmoid_cross_entropy_with_logits( labels=tf.zeros_like(fake_logits), logits=fake_logits)) return real_loss + fake_loss def vgg_loss(weight=None, input_shape=None): - """ Perceptual Loss calculation using pre-trained VGG19 - model before activation as mentioned in the paper. + """Perceptual Loss calculation using pre-trained VGG19 + model before activation as mentioned in the paper. Args: weights: Weights to be loaded. input_shape: Shape of input image. diff --git a/tensorflow_gan/examples/esrgan/losses_test.py b/tensorflow_gan/examples/esrgan/losses_test.py index 4285b7f..a34872c 100644 --- a/tensorflow_gan/examples/esrgan/losses_test.py +++ b/tensorflow_gan/examples/esrgan/losses_test.py @@ -13,15 +13,16 @@ # See the License for the specific language governing permissions and # limitations under the License. -"""Tests for tfgan.examples.esrgan.losses""" +"""Tests for tfgan.examples.esrgan.losses.""" -from absl.testing import absltest import os +from absl.testing import absltest import tensorflow as tf import losses class LossesTest(tf.test.TestCase, absltest.TestCase): + """Tests for relativistic losses and pixel loss.""" def setUp(self): super(LossesTest, self).setUp() self.real_data = tf.constant([[3.1, 2.3, -12.3, 32.1]]) diff --git a/tensorflow_gan/examples/esrgan/networks.py b/tensorflow_gan/examples/esrgan/networks.py index e50b8ce..ad766b2 100644 --- a/tensorflow_gan/examples/esrgan/networks.py +++ b/tensorflow_gan/examples/esrgan/networks.py @@ -13,30 +13,29 @@ # See the License for the specific language governing permissions and # limitations under the License. -import os +"""Implementation of Generator (ESRGAN_G) and Discriminator (ESRGAN_D) models + based on the architecture proposed in the paper 'ESRGAN: Enhanced + Super-Resolution Generative Adversarial Networks'. + (https://arxiv.org/abs/1809.00219). +""" + import tensorflow as tf from tensorflow.keras import layers -""" -Implementation of Generator (ESRGAN_G) and Discriminator (ESRGAN_D) models -based on the architecture proposed in the paper -'ESRGAN: Enhanced Super-Resolution Generative Adversarial Networks'. -""" - def _conv_block(input, filters, activation=True): - h = layers.Conv2D(filters, kernel_size=[3,3], + h = layers.Conv2D(filters, kernel_size=[3, 3], kernel_initializer="he_normal", bias_initializer="zeros", - strides=[1,1], padding='same', use_bias=True)(input) + strides=[1, 1], padding='same', use_bias=True)(input) if activation: h = layers.LeakyReLU(0.2)(h) return h def _conv_block_d(input, out_channel): - x = layers.Conv2D(out_channel, 3,1, padding='same', use_bias=False)(input) + x = layers.Conv2D(out_channel, 3, 1, padding='same', use_bias=False)(input) x = layers.BatchNormalization(momentum=0.8)(x) x = layers.LeakyReLU(alpha=0.2)(x) - x = layers.Conv2D(out_channel, 4,2, padding='same', use_bias=False)(x) + x = layers.Conv2D(out_channel, 4, 2, padding='same', use_bias=False)(x) x = layers.BatchNormalization(momentum=0.8)(x) x = layers.LeakyReLU(alpha=0.2)(x) return x @@ -65,23 +64,22 @@ def rrdb(input): h = dense_block(input) h = dense_block(h) h = dense_block(h) - h = layers.Lambda(lambda x:x * 0.2)(h) + h = layers.Lambda(lambda x: x * 0.2)(h) out = layers.Add()([h, input]) return out def upsample(x, filters): x = layers.Conv2DTranspose(filters, kernel_size=3, strides=2, padding='same', - use_bias = True)(x) + use_bias=True)(x) x = layers.LeakyReLU(alpha=0.2)(x) return x def generator_network(hparams, num_filters=32, out_channels=3): - """ - The Generator network for ESRGAN consisting of Residual in Residual Block - as the basic building unit. + """The Generator network for ESRGAN consisting of Residual in Residual + Block as the basic building unit. Args : num_filters : Number of num_filters for the convolutional layers used. @@ -95,7 +93,7 @@ def generator_network(hparams, outputs -> Batch of generated HR images. """ lr_input = layers.Input(shape=(hparams.hr_dimension//hparams.scale, - hparams.hr_dimension//hparams.scale, 3)) + hparams.hr_dimension//hparams.scale, 3)) x = layers.Conv2D(num_filters, kernel_size=[3, 3], strides=[1, 1], padding='same', use_bias=True)(lr_input) @@ -107,7 +105,7 @@ def generator_network(hparams, x = rrdb(x) x = layers.Conv2D(num_filters, kernel_size=[3, 3], strides=[1, 1], - padding='same', use_bias=True)(x) + padding='same', use_bias=True)(x) x = layers.Add()([x, ref]) x = upsample(x, num_filters) @@ -126,8 +124,7 @@ def generator_network(hparams, def discriminator_network(hparams, num_filters=64, training=True): - """ - The discriminator network for ESRGAN. + """The discriminator network for ESRGAN. Args : num_filters : Number of filters for the first convolutional layer. @@ -139,11 +136,11 @@ def discriminator_network(hparams, """ img = layers.Input(shape=(hparams.hr_dimension, hparams.hr_dimension, 3)) - x = layers.Conv2D(num_filters, [3,3], 1, padding='same', use_bias=False)(img) + x = layers.Conv2D(num_filters, [3, 3], 1, padding='same', use_bias=False)(img) x = layers.BatchNormalization()(x) x = layers.LeakyReLU(alpha=0.2)(x) - x = layers.Conv2D(num_filters, [3,3], 2, padding='same', use_bias=False)(x) + x = layers.Conv2D(num_filters, [3, 3], 2, padding='same', use_bias=False)(x) x = layers.BatchNormalization()(x) x = layers.LeakyReLU(alpha=0.2)(x) @@ -156,5 +153,5 @@ def discriminator_network(hparams, x = layers.LeakyReLU(alpha=0.2)(x) x = layers.Dense(1)(x) - model = tf.keras.models.Model(inputs = img, outputs = x) + model = tf.keras.models.Model(inputs=img, outputs=x) return model diff --git a/tensorflow_gan/examples/esrgan/networks_test.py b/tensorflow_gan/examples/esrgan/networks_test.py index 48777e7..2da6fb2 100644 --- a/tensorflow_gan/examples/esrgan/networks_test.py +++ b/tensorflow_gan/examples/esrgan/networks_test.py @@ -13,28 +13,28 @@ # See the License for the specific language governing permissions and # limitations under the License. -"""Tests for tfgan.examples.esrgan.networks""" +"""Tests for tfgan.examples.esrgan.networks.""" +import collections import tensorflow as tf import networks -import collections -hparams = collections.namedtuple('hparams', ['hr_dimension', - 'scale', - 'trunk_size']) +HParams = collections.namedtuple('HParams', ['hr_dimension', + 'scale', + 'trunk_size']) class NetworksTest(tf.test.TestCase): def setUp(self): - self.hparams = hparams(256, 4, 11) + self.hparams = HParams(256, 4, 11) self.generator = networks.generator_network(self.hparams) self.discriminator = networks.discriminator_network(self.hparams) def test_network_type(self): - """ Verifies that the models are of keras.Model type """ + """Verifies that the models are of keras.Model type.""" self.assertIsInstance(self.generator, tf.keras.Model) self.assertIsInstance(self.discriminator, tf.keras.Model) def test_generator(self): - """ Verifies the generator output shape.""" + """Verifies the generator output shape.""" img_batch = tf.random.uniform([3, 64, 64, 3]) target_shape = [3, 256, 256, 3] model_output = self.generator(img_batch) @@ -43,7 +43,7 @@ def test_generator(self): self.assertEqual(model_output.shape, target_shape) def test_generator_inference(self): - """ Check one inference step.""" + """Check one inference step.""" img_batch = tf.zeros([2, 64, 64, 3]) model_output, _ = self.generator(img_batch) with self.cached_session() as sess: diff --git a/tensorflow_gan/examples/esrgan/train.py b/tensorflow_gan/examples/esrgan/train.py index 536481c..2e25f09 100644 --- a/tensorflow_gan/examples/esrgan/train.py +++ b/tensorflow_gan/examples/esrgan/train.py @@ -13,6 +13,8 @@ # See the License for the specific language governing permissions and # limitations under the License. +"""Code for training the ESRGAN model.""" + from absl import flags, logging, app import train_lib import data_provider diff --git a/tensorflow_gan/examples/esrgan/train_lib.py b/tensorflow_gan/examples/esrgan/train_lib.py index 03869a1..5df7fba 100644 --- a/tensorflow_gan/examples/esrgan/train_lib.py +++ b/tensorflow_gan/examples/esrgan/train_lib.py @@ -13,20 +13,18 @@ # See the License for the specific language governing permissions and # limitations under the License. -"""Train the ESRGAN model -See https://arxiv.org/abs/1809.00219 for details about the model. -""" +"""Code for training the ESRGAN model.""" -import tensorflow as tf -import collections import os +import collections +import tensorflow as tf from absl import logging import networks import losses import utils -hparams = collections.namedtuple('hparams', [ +HParams = collections.namedtuple('HParams', [ 'batch_size', 'scale', 'model_dir', 'phase_1', 'phase_2', 'hr_dimension', @@ -39,8 +37,8 @@ 'eta', 'image_dir']) def pretrain_generator(hparams, data): - """ Pre-trains the generator network with pixel-loss as proposed in - the paper and saves the network inside the model directory specified. + """Pre-trains the generator network with pixel-loss as proposed in + the paper and saves the network inside the model directory specified. Args: hparams : Training parameters as proposed in the paper. @@ -63,8 +61,8 @@ def pretrain_generator(hparams, data): g_optimizer = _get_optimizer() def train_step(image_lr, image_hr): - """ Calculates the L1 Loss and gradients at each step, and updates the - gradient to improve the PSNR values. + """Calculates the L1 Loss and gradients at each step, and updates the + gradient to improve the PSNR values. Args: image_lr : batch of tensors representing LR images. image_hr : batch of tensors representing HR images. @@ -151,8 +149,8 @@ def train_esrgan(hparams, data): psnr_metric = tf.keras.metrics.Mean() def train_step(image_lr, image_hr, step): - """ Calculates the L1 Loss, Perceptual loss and RaGAN loss, to train - both generator and discriminator networks of the ESRGAN model. + """Calculates the L1 Loss, Perceptual loss and RaGAN loss, to train + both generator and discriminator networks of the ESRGAN model. Args : image_lr : batch of tensors representing LR images. image_hr : batch of tensors representing HR images. @@ -196,25 +194,25 @@ def train_step(image_lr, image_hr, step): return gen_loss, disc_loss, psnr def val_step(image_lr, image_hr, step): - """ Saves an image grid containing LR image, generated image and - HR image, inside the image directory. + """Saves an image grid containing LR image, generated image and + HR image, inside the image directory. Args: image_lr : Low Resolution Image image_hr : High Resolution Image. step : Number of steps completed, used for naming the image file. """ - fake=generator(image_lr) + fake = generator(image_lr) utils.visualize_results(image_lr, fake, image_hr, - hparams.image_dir, + image_dir=hparams.image_dir, step=step) step = 0 # Modify learning rate at each of these steps decay_list = [50000, 100000, 200000, 300000] - index=0 + index = 0 for lr, hr in data.take(hparams.total_steps): step += 1 @@ -240,7 +238,7 @@ def val_step(image_lr, image_hr, step): d_optimizer.learning_rate.assign( d_optimizer.learning_rate * hparams.decay_factor) - index+=1 + index += 1 # Save the generator model inside model_dir. @@ -262,8 +260,7 @@ def val_step(image_lr, image_hr, step): def _get_optimizer(lr=0.0002, beta_1=0.9, beta_2=0.99): """Returns the Adam optimizer with the specified learning rate.""" - optimizer = tf.optimizers.Adam( - learning_rate=lr, - beta_1=beta_1, - beta_2=beta_2) + optimizer = tf.optimizers.Adam(learning_rate=lr, + beta_1=beta_1, + beta_2=beta_2) return optimizer diff --git a/tensorflow_gan/examples/esrgan/train_test.py b/tensorflow_gan/examples/esrgan/train_test.py index 1b9b3bc..14d67c0 100644 --- a/tensorflow_gan/examples/esrgan/train_test.py +++ b/tensorflow_gan/examples/esrgan/train_test.py @@ -13,34 +13,23 @@ # See the License for the specific language governing permissions and # limitations under the License. -"""Tests for tfgan.examples.esrgan.train""" +"""Tests for tfgan.examples.esrgan.train.""" -from absl.testing import absltest import collections - import tensorflow as tf import train_lib mock = tf.compat.v1.test.mock -hparams = collections.namedtuple('hparams', [ - 'batch_size', 'scale', - 'model_dir', 'phase_1', - 'phase_2', 'hr_dimension', - 'data_dir', 'print_steps', - 'trunk_size', 'total_steps', - 'decay_steps', 'decay_factor', - 'lr', 'beta_1', - 'beta_2', 'init_lr', - 'loss_type', 'lambda_', - 'eta', 'image_dir']) + class TrainTest(tf.test.TestCase): def setUp(self): - self.hparams = hparams(32, 4, '/content/', - False, False, 256, - '/content/', 1, 11, 1, 1, - 0.5, 0.0001, 0.5, 0.001, 0.00005, - 'L1', 0.001, 0.5, '/content/') + # Parameters for a single step of training. + self.hparams = train_lib.HParams(32, 4, '/content/', + False, False, 256, + '/content/', 1, 11, 1, 1, + 0.5, 0.0001, 0.5, 0.001, 0.00005, + 'L1', 0.001, 0.5, '/content/') d = tf.data.Dataset.from_tensor_slices(tf.random.normal([32, 256, 256, 3])) def lr(hr): lr = tf.image.resize(hr, [64, 64], method='bicubic') @@ -51,14 +40,12 @@ def lr(hr): self.mock_dataset = d def test_pretrain_generator(self): - """ Executes all the processes inside the phase-1 training step, once. - (takes about 100s)""" - self.assertIsNone(train_lib.pretrain_generator(self.HParams, self.mock_dataset)) + """Executes all the processes inside the phase-1 training step, once.""" + self.assertIsNone(train_lib.pretrain_generator(self.hparams, self.mock_dataset)) def test_train_generator(self): - """ Executes the phase-2 training step for a single step, once - (takes about 220s)""" - self.assertIsNone(train_lib.train_esrgan(self.HParams, self.mock_dataset)) + """Executes the phase-2 training step for a single step, once.""" + self.assertIsNone(train_lib.train_esrgan(self.hparams, self.mock_dataset)) if __name__ == '__main__': tf.test.main() diff --git a/tensorflow_gan/examples/esrgan/utils.py b/tensorflow_gan/examples/esrgan/utils.py index 28a1a17..7569573 100644 --- a/tensorflow_gan/examples/esrgan/utils.py +++ b/tensorflow_gan/examples/esrgan/utils.py @@ -13,6 +13,8 @@ # See the License for the specific language governing permissions and # limitations under the License. +"""Code for training the ESRGAN model.""" + import os import tensorflow as tf import tensorflow_gan as tfgan @@ -22,12 +24,13 @@ def preprocess_input(image): - """ Input images are preprocessed by subtracting the dataset mean. - Since the VGG-19 network used here to extract features, is pretrained - on ImageNet dataset, its mean value (103.939, 116.779, 123.68) is subtracted - from the input images. - This ensures that each feature will have a similar range and the gradients - calculated during training are stable. + """Input images are preprocessed by subtracting the dataset mean. + + Since the VGG-19 network used here to extract features, is pretrained + on ImageNet dataset, its mean value (103.939, 116.779, 123.68) is subtracted + from the input images. + This ensures that each feature will have a similar range and the gradients + calculated during training are stable. """ image = image[..., ::-1] mean = -tf.constant([103.939, 116.779, 123.68]) @@ -42,8 +45,8 @@ def visualize_results(image_lr, step=0, train=True): - """ Creates an image grid using Tf-GAN's image grid function and - saves the results as a .png image. + """Creates an image grid using Tf-GAN's image grid function and + saves the results as a .png image. Args: image_lr : Batch of tensors representing LR images. @@ -80,12 +83,13 @@ def visualize_results(image_lr, def network_interpolation(alpha=0.2, phase_1_path=None, phase_2_path=None): - """ Network interpolation as explained in section 3.4 in the paper, bascically - balancing the effects of PSNR oriented methods and GAN based methods. + """Network interpolation as explained in section 3.4 in the paper, bascically + balancing the effects of PSNR oriented methods and GAN based methods. Args: alpha : interpolation parameter. phase_1_path : path to the network saved after phase 1 training. phase_2_path : path to the network saved after phase 2 training. + Returns: Interpolated generator network. """ @@ -105,7 +109,7 @@ def network_interpolation(alpha=0.2, # Utility functions for evaluation def get_frechet_inception_distance(real_images, generated_images, batch_size, num_inception_images): - """ Get Frechet Inception Distance between real and generated images. + """Get Frechet Inception Distance between real and generated images. Args: real_images: Real images minibatch. @@ -140,7 +144,7 @@ def get_frechet_inception_distance(real_images, generated_images, batch_size, def get_inception_scores(images, batch_size, num_inception_images): - """ Calculate Inception score for images. + """Calculate Inception score for images. Args: images : A batch of tensors representing series of images. @@ -176,7 +180,7 @@ def get_inception_scores(images, batch_size, num_inception_images): return inc_score def get_psnr(real, generated): - """ Calculate PSNR values for the given samples of images. + """Calculate PSNR values for the given samples of images. Args: real: batch of tensors representing real images. diff --git a/tensorflow_gan/examples/esrgan/utils_test.py b/tensorflow_gan/examples/esrgan/utils_test.py index c67c8b4..d8f8129 100644 --- a/tensorflow_gan/examples/esrgan/utils_test.py +++ b/tensorflow_gan/examples/esrgan/utils_test.py @@ -13,30 +13,28 @@ # See the License for the specific language governing permissions and # limitations under the License. -"""Tests for tfgan.examples.esrgan.utils""" +"""Tests for tfgan.examples.esrgan.utils.""" -from absl.testing import absltest import collections - import tensorflow as tf import utils import networks -Params = collections.namedtuple('HParams', ['hr_dimension', - 'scale', - 'trunk_size', - 'path']) +HParams = collections.namedtuple('HParams', ['hr_dimension', + 'scale', + 'trunk_size', + 'path']) class UtilsTest(tf.test.TestCase): def setUp(self): super(UtilsTest, self).setUp() - self.HParams = Params(256, 4, 11, '/content/') + self.hparams = HParams(256, 4, 11, '/content/') - self.generator1 = networks.generator_network(self.HParams) - self.generator1.save(self.HParams.path+'1/') - self.generator2 = networks.generator_network(self.HParams) - self.generator1.save(self.HParams.path+'2/') + self.generator1 = networks.generator_network(self.hparams) + self.generator1.save(self.hparams.path+'1/') + self.generator2 = networks.generator_network(self.hparams) + self.generator1.save(self.hparams.path+'2/') self.hr_data = tf.random.normal([2,256,256,3]) self.lr_data = tf.random.normal([2,64,64,3]) @@ -66,9 +64,9 @@ def test_inception_score(self): self.assertEqual(is_score.dtype, tf.float32) def test_interpolation(self): - """ To test the interpolation function. """ - inter_gen = utils.network_interpolation(phase_1_path=self.HParams.path+'1/', - phase_2_path=self.HParams.path+'2/') + """ To test the interpolation function.""" + inter_gen = utils.network_interpolation(phase_1_path=self.hparams.path+'1/', + phase_2_path=self.hparams.path+'2/') self.assertEqual(type(inter_gen), type(self.generator1)) if __name__ == '__main__': From 425d36270f3902f54244ad245153c8125dfdf4ca Mon Sep 17 00:00:00 2001 From: supertramp2 Date: Sun, 5 Sep 2021 22:40:23 +0530 Subject: [PATCH 19/20] Lint --- .../examples/esrgan/data_provider.py | 29 +++++---- tensorflow_gan/examples/esrgan/eval.py | 5 +- tensorflow_gan/examples/esrgan/eval_lib.py | 9 ++- tensorflow_gan/examples/esrgan/eval_test.py | 4 +- tensorflow_gan/examples/esrgan/losses.py | 29 ++++----- tensorflow_gan/examples/esrgan/losses_test.py | 1 - tensorflow_gan/examples/esrgan/networks.py | 60 ++++++++++--------- .../examples/esrgan/networks_test.py | 1 + tensorflow_gan/examples/esrgan/train.py | 5 +- tensorflow_gan/examples/esrgan/train_lib.py | 51 ++++++++-------- tensorflow_gan/examples/esrgan/train_test.py | 7 ++- tensorflow_gan/examples/esrgan/utils.py | 20 ++++--- tensorflow_gan/examples/esrgan/utils_test.py | 11 ++-- 13 files changed, 126 insertions(+), 106 deletions(-) diff --git a/tensorflow_gan/examples/esrgan/data_provider.py b/tensorflow_gan/examples/esrgan/data_provider.py index cd54962..8e6591e 100644 --- a/tensorflow_gan/examples/esrgan/data_provider.py +++ b/tensorflow_gan/examples/esrgan/data_provider.py @@ -23,11 +23,11 @@ def random_flip(lr_img, hr_img): """Randomly flips LR and HR images for data augmentation.""" random = tf.random.uniform(shape=(), maxval=1) - - return tf.cond(random<0.5, + flip_lr = tf.image.flip_left_right(lr_img) + flip_hr = tf.image.flip_left_right(hr_img) + return tf.cond(random < 0.5, lambda: (lr_img, hr_img), - lambda: (tf.image.flip_left_right(lr_img), - tf.image.flip_left_right(hr_img))) + lambda: (flip_lr, flip_hr)) def random_rotate(lr_img, hr_img): """Randomly rotates LR and HR images for data augmentation.""" @@ -35,11 +35,12 @@ def random_rotate(lr_img, hr_img): return tf.image.rot90(lr_img, random), tf.image.rot90(hr_img, random) -def get_div2k_data(hparams, +def get_div2k_data(hparams, name='div2k/bicubic_x4', mode='train', - shuffle=True, - repeat_count=None): + shuffle=True, + repeat_count=None, + augment=True): """Downloads and loads DIV2K dataset. Args: hparams : A named tuple to store different parameters. @@ -47,6 +48,7 @@ def get_div2k_data(hparams, mode : Either 'train' or 'valid'. shuffle : Whether to shuffle the images in the dataset. repeat_count : Repetition of data during training. + augment : Whether to augment the dataset or not. Returns: A tf.data.Dataset with pairs of LR image and HR image tensors. @@ -55,13 +57,15 @@ def get_div2k_data(hparams, """ split = 'train' if mode == 'train' else 'validation' - def scale(image, *args): + def scale(data): + image = data['hr'] hr_size = hparams.hr_dimension scale = hparams.scale hr_image = image hr_image = tf.image.resize(hr_image, [hr_size, hr_size]) - lr_image = tf.image.resize(hr_image, [hr_size//scale, hr_size//scale], method='bicubic') + lr_image = tf.image.resize(hr_image, [hr_size//scale, hr_size//scale], + method='bicubic') hr_image = tf.clip_by_value(hr_image, 0, 255) lr_image = tf.clip_by_value(lr_image, 0, 255) @@ -70,8 +74,7 @@ def scale(image, *args): dataset = (tfds.load(name=name, split=split, - data_dir=hparams.data_dir, - as_supervised=True) + data_dir=hparams.data_dir) .map(scale, num_parallel_calls=AUTOTUNE) .cache()) @@ -79,6 +82,10 @@ def scale(image, *args): dataset = dataset.shuffle( buffer_size=10000, reshuffle_each_iteration=True) + if augment: + dataset = dataset. map(random_flip) + dataset = dataset.map(random_rotate) + dataset = dataset.batch(hparams.batch_size) dataset = dataset.repeat(repeat_count) dataset = dataset.prefetch(buffer_size=AUTOTUNE) diff --git a/tensorflow_gan/examples/esrgan/eval.py b/tensorflow_gan/examples/esrgan/eval.py index 768c15b..cd2e0c4 100644 --- a/tensorflow_gan/examples/esrgan/eval.py +++ b/tensorflow_gan/examples/esrgan/eval.py @@ -15,7 +15,10 @@ """Contains code for evaluating ESRGAN model.""" -from absl import flags, logging, app +from absl import flags +from absl import logging +from absl import app + import tensorflow as tf import eval_lib import data_provider diff --git a/tensorflow_gan/examples/esrgan/eval_lib.py b/tensorflow_gan/examples/esrgan/eval_lib.py index 2093f40..fe43c86 100644 --- a/tensorflow_gan/examples/esrgan/eval_lib.py +++ b/tensorflow_gan/examples/esrgan/eval_lib.py @@ -28,9 +28,8 @@ 'eval_real_images']) def evaluate(hparams, generator, data): - """Runs an evaluation loop and calculates the mean FID, - Inception and PSNR scores observed on the validation dataset. - + """ Runs the evaluation loop once. + Args: hparams: Parameters for evaluation. generator : The trained generator network. @@ -75,5 +74,5 @@ def evaluate(hparams, generator, data): psnr = utils.get_psnr(hr, gen) psnr_metric(psnr) - logging.info('FID Score :{}\tInception Score :{}\tPSNR value :{}'.format( - fid_metric.result(), inc_metric.result(), psnr_metric.result())) + logging.info('FID Score :%f\tInception Score :%f\tPSNR value :%f', + fid_metric.result(), inc_metric.result(), psnr_metric.result()) diff --git a/tensorflow_gan/examples/esrgan/eval_test.py b/tensorflow_gan/examples/esrgan/eval_test.py index b68fadf..80793b0 100644 --- a/tensorflow_gan/examples/esrgan/eval_test.py +++ b/tensorflow_gan/examples/esrgan/eval_test.py @@ -13,7 +13,7 @@ # See the License for the specific language governing permissions and # limitations under the License. -"""Tests for tfgan.examples.esrgan.eval""" +"""Tests for tfgan.examples.esrgan.eval.""" import collections @@ -27,6 +27,7 @@ class EvalTest(tf.test.TestCase): def setUp(self): + super(EvalTest, self).setUp() self.hparams = HParams(1, '/content/', 2, 2, True, 256, @@ -49,4 +50,3 @@ def test_eval(self): if __name__ == '__main__': tf.test.main() - diff --git a/tensorflow_gan/examples/esrgan/losses.py b/tensorflow_gan/examples/esrgan/losses.py index 598b38d..34cf93e 100644 --- a/tensorflow_gan/examples/esrgan/losses.py +++ b/tensorflow_gan/examples/esrgan/losses.py @@ -19,28 +19,30 @@ def pixel_loss(y_true, y_pred): """To calculate the L1 Loss. - Args : + + Args: y_true : Original HR image present in the dataset. y_pred : Image generated by the generator network. - Returns : + + Returns: Mean absolute difference between the two images. """ y_true = tf.cast(y_true, tf.float32) y_pred = tf.cast(y_pred, tf.float32) return tf.reduce_mean(tf.reduce_mean(tf.abs(y_true - y_pred), axis=0)) -# TODO(Nived): Remove this function once the relativitic losses are added to TF-GAN +# TODO(nivedwho): Remove this once the relativitic losses are added to TF-GAN. def ragan_generator_loss(d_real, d_fake, scope=None): - """To calculate the adversarial loss for generator - network using a relativistic discriminator. + """To calculate the adversarial loss for generator. Args: d_real: Discriminator output on real data. d_fake: Discriminator output on generated data. Expected to be in the range of (-inf, inf). scope: The scope for the operations performed in computing the loss. + Returns: Adversarial loss for generator. """ @@ -60,12 +62,11 @@ def get_logits(x, y): return real_loss + fake_loss -# TODO(Nived): Remove this function once the relativitic losses are added to TF-GAN +# TODO(nivedwho): Remove this once the relativitic losses are added to TF-GAN. def ragan_discriminator_loss(d_real, d_fake, scope=None): - """To calculate the adversarial loss for discriminator - network using a relativistic discriminator. + """To calculate the adversarial loss for discriminator. Args: d_real: Discriminator output on real data. @@ -93,14 +94,14 @@ def get_logits(x, y): return real_loss + fake_loss def vgg_loss(weight=None, input_shape=None): - """Perceptual Loss calculation using pre-trained VGG19 - model before activation as mentioned in the paper. + """Perceptual Loss calculation using pre-trained VGG19. + Args: - weights: Weights to be loaded. + weight: Weights to be loaded. input_shape: Shape of input image. - Returns : - Perceptual loss + Returns: + The calculated perceptual loss. """ vgg_model = tf.keras.applications.vgg19.VGG19( input_shape=input_shape, weights=weight, include_top=False @@ -108,7 +109,7 @@ def vgg_loss(weight=None, input_shape=None): for layer in vgg_model.layers: layer.trainable = False - + # Features before activation are used as mentioned in the paper. vgg_model.get_layer("block5_conv4").activation = lambda x: x vgg = tf.keras.Model( inputs=[vgg_model.input], diff --git a/tensorflow_gan/examples/esrgan/losses_test.py b/tensorflow_gan/examples/esrgan/losses_test.py index a34872c..02b8b7f 100644 --- a/tensorflow_gan/examples/esrgan/losses_test.py +++ b/tensorflow_gan/examples/esrgan/losses_test.py @@ -15,7 +15,6 @@ """Tests for tfgan.examples.esrgan.losses.""" -import os from absl.testing import absltest import tensorflow as tf diff --git a/tensorflow_gan/examples/esrgan/networks.py b/tensorflow_gan/examples/esrgan/networks.py index ad766b2..6a86d5b 100644 --- a/tensorflow_gan/examples/esrgan/networks.py +++ b/tensorflow_gan/examples/esrgan/networks.py @@ -13,25 +13,28 @@ # See the License for the specific language governing permissions and # limitations under the License. -"""Implementation of Generator (ESRGAN_G) and Discriminator (ESRGAN_D) models - based on the architecture proposed in the paper 'ESRGAN: Enhanced - Super-Resolution Generative Adversarial Networks'. - (https://arxiv.org/abs/1809.00219). +"""Implementation of the generator and discriminator networks. + +Based on the architecture proposed in the paper 'ESRGAN: Enhanced +Super-Resolution Generative Adversarial Networks'. +(https://arxiv.org/abs/1809.00219) """ import tensorflow as tf from tensorflow.keras import layers -def _conv_block(input, filters, activation=True): +def _conv_block(x, filters, activation=True): + """Convolutional block used for building generator network.""" h = layers.Conv2D(filters, kernel_size=[3, 3], kernel_initializer="he_normal", bias_initializer="zeros", - strides=[1, 1], padding='same', use_bias=True)(input) + strides=[1, 1], padding='same', use_bias=True)(x) if activation: - h = layers.LeakyReLU(0.2)(h) + h = layers.LeakyReLU(0.2)(h) return h -def _conv_block_d(input, out_channel): - x = layers.Conv2D(out_channel, 3, 1, padding='same', use_bias=False)(input) +def _conv_block_d(x, out_channel): + """Convolutional block used for building discriminator network.""" + x = layers.Conv2D(out_channel, 3, 1, padding='same', use_bias=False)(x) x = layers.BatchNormalization(momentum=0.8)(x) x = layers.LeakyReLU(alpha=0.2)(x) @@ -40,35 +43,38 @@ def _conv_block_d(input, out_channel): x = layers.LeakyReLU(alpha=0.2)(x) return x -def dense_block(input): - h1 = _conv_block(input, 32) - h1 = layers.Concatenate()([input, h1]) +def dense_block(x): + """Dense block used inside RRDB.""" + h1 = _conv_block(x, 32) + h1 = layers.Concatenate()([x, h1]) h2 = _conv_block(h1, 32) - h2 = layers.Concatenate()([input, h1, h2]) + h2 = layers.Concatenate()([x, h1, h2]) h3 = _conv_block(h2, 32) - h3 = layers.Concatenate()([input, h1, h2, h3]) + h3 = layers.Concatenate()([x, h1, h2, h3]) h4 = _conv_block(h3, 32) - h4 = layers.Concatenate()([input, h1, h2, h3, h4]) + h4 = layers.Concatenate()([x, h1, h2, h3, h4]) h5 = _conv_block(h4, 32, activation=False) h5 = layers.Lambda(lambda x: x * 0.2)(h5) - h = layers.Add()([h5, input]) + h = layers.Add()([h5, x]) return h -def rrdb(input): - h = dense_block(input) +def rrdb(x): + """Residual-in-Residual Dense Block used in the generator.""" + h = dense_block(x) h = dense_block(h) h = dense_block(h) h = layers.Lambda(lambda x: x * 0.2)(h) - out = layers.Add()([h, input]) + out = layers.Add()([h, x]) return out def upsample(x, filters): + """Upsampling layer for the generator.""" x = layers.Conv2DTranspose(filters, kernel_size=3, strides=2, padding='same', use_bias=True)(x) @@ -78,10 +84,9 @@ def upsample(x, filters): def generator_network(hparams, num_filters=32, out_channels=3): - """The Generator network for ESRGAN consisting of Residual in Residual - Block as the basic building unit. + """The generator network for the ESRGAN model. - Args : + Args: num_filters : Number of num_filters for the convolutional layers used. out_channels : Number of channels for the generated image. use_bias : Whether to use bias or not for the convolutional layers. @@ -121,14 +126,12 @@ def generator_network(hparams, return model -def discriminator_network(hparams, - num_filters=64, - training=True): - """The discriminator network for ESRGAN. +def discriminator_network(hparams, num_filters=64): + """The discriminator network for the ESRGAN model. - Args : + Args: num_filters : Number of filters for the first convolutional layer. - Returns : + Returns: The compiled model of the discriminator network where the inputs and outputs of the model are defined as : inputs -> Batch of tensors representing HR images. @@ -155,3 +158,4 @@ def discriminator_network(hparams, model = tf.keras.models.Model(inputs=img, outputs=x) return model + diff --git a/tensorflow_gan/examples/esrgan/networks_test.py b/tensorflow_gan/examples/esrgan/networks_test.py index 2da6fb2..20b8a92 100644 --- a/tensorflow_gan/examples/esrgan/networks_test.py +++ b/tensorflow_gan/examples/esrgan/networks_test.py @@ -24,6 +24,7 @@ 'trunk_size']) class NetworksTest(tf.test.TestCase): def setUp(self): + super(NetworksTest, self).setUp() self.hparams = HParams(256, 4, 11) self.generator = networks.generator_network(self.hparams) self.discriminator = networks.discriminator_network(self.hparams) diff --git a/tensorflow_gan/examples/esrgan/train.py b/tensorflow_gan/examples/esrgan/train.py index 2e25f09..fc17866 100644 --- a/tensorflow_gan/examples/esrgan/train.py +++ b/tensorflow_gan/examples/esrgan/train.py @@ -15,7 +15,10 @@ """Code for training the ESRGAN model.""" -from absl import flags, logging, app +from absl import flags +from absl import logging +from absl import app + import train_lib import data_provider diff --git a/tensorflow_gan/examples/esrgan/train_lib.py b/tensorflow_gan/examples/esrgan/train_lib.py index 5df7fba..7ab4fcc 100644 --- a/tensorflow_gan/examples/esrgan/train_lib.py +++ b/tensorflow_gan/examples/esrgan/train_lib.py @@ -37,8 +37,7 @@ 'eta', 'image_dir']) def pretrain_generator(hparams, data): - """Pre-trains the generator network with pixel-loss as proposed in - the paper and saves the network inside the model directory specified. + """Pre-trains the generator network with pixel-loss. Args: hparams : Training parameters as proposed in the paper. @@ -56,13 +55,13 @@ def pretrain_generator(hparams, data): else: generator = networks.generator_network(hparams) - logging.info("Starting Phase-1 training of generator using only pixel loss function.") + logging.info("Starting Phase-1 training using only pixel loss function.") g_optimizer = _get_optimizer() def train_step(image_lr, image_hr): - """Calculates the L1 Loss and gradients at each step, and updates the - gradient to improve the PSNR values. + """Calculates the L1 Loss and gradients at each step. + Args: image_lr : batch of tensors representing LR images. image_hr : batch of tensors representing HR images. @@ -94,8 +93,8 @@ def train_step(image_lr, image_hr): psnr_metric(psnr) if step % hparams.print_steps == 0: - logging.info("Step: {}\tGenerator Loss: {}\tPSNR: {}".format( - step, metric.result(), psnr_metric.result())) + logging.info("Step:%f\tGenerator Loss:%f\tPSNR:%f", + step, metric.result(), psnr_metric.result()) # Modify the learning rate as mentioned in the paper. if step % hparams.decay_steps == 0: @@ -108,8 +107,7 @@ def train_step(image_lr, image_hr): logging.info("Saved pre-trained generator network succesfully!") def train_esrgan(hparams, data): - """Loads the pre-trained generator model and trains the ESRGAN network - using L1 Loss, Perceptual loss and RaGAN loss function. + """Trains the ESRGAN network. Args: hparams : Training parameters as proposed in the paper. @@ -148,14 +146,14 @@ def train_esrgan(hparams, data): disc_metric = tf.keras.metrics.Mean() psnr_metric = tf.keras.metrics.Mean() - def train_step(image_lr, image_hr, step): - """Calculates the L1 Loss, Perceptual loss and RaGAN loss, to train - both generator and discriminator networks of the ESRGAN model. - Args : + def train_step(image_lr, image_hr): + """Calculates the L1 Loss, Perceptual loss and Relativstic loss. + + Args: image_lr : batch of tensors representing LR images. image_hr : batch of tensors representing HR images. - Returns : + Returns: PSNR values, generator loss and discriminator obtained in each step. """ with tf.GradientTape() as gen_tape, tf.GradientTape() as disc_tape: @@ -168,13 +166,13 @@ def train_step(image_lr, image_hr, step): percep_loss = tf.reduce_mean(perceptual_loss(image_hr, fake)) l1_loss = losses.pixel_loss(image_hr, fake) - # TODO(Nived): Replace these functions once TF-GAN losses are updated. - loss_RaG = losses.ragan_generator_loss(discriminator(image_hr), + # TODO(nivedwho): Replace these functions once TF-GAN losses are updated. + gen_loss = losses.ragan_generator_loss(discriminator(image_hr), discriminator(fake)) disc_loss = losses.ragan_discriminator_loss(discriminator(image_hr), discriminator(fake)) - gen_loss = percep_loss + hparams.lambda_ * loss_RaG + hparams.eta * l1_loss + gen_loss = percep_loss + hparams.lambda_ * gen_loss + hparams.eta * l1_loss gen_loss = gen_loss * (1.0 / hparams.batch_size) disc_loss = disc_loss * (1.0 / hparams.batch_size) @@ -194,8 +192,8 @@ def train_step(image_lr, image_hr, step): return gen_loss, disc_loss, psnr def val_step(image_lr, image_hr, step): - """Saves an image grid containing LR image, generated image and - HR image, inside the image directory. + """Saves an image grid with LR image, generated image and HR image. + Args: image_lr : Low Resolution Image image_hr : High Resolution Image. @@ -203,8 +201,8 @@ def val_step(image_lr, image_hr, step): file. """ fake = generator(image_lr) - utils.visualize_results(image_lr, - fake, + utils.visualize_results(image_lr, + fake, image_hr, image_dir=hparams.image_dir, step=step) @@ -219,16 +217,17 @@ def val_step(image_lr, image_hr, step): lr = tf.cast(lr, tf.float32) hr = tf.cast(hr, tf.float32) - gen_loss, disc_loss, psnr = train_step(lr, hr, step) + gen_loss, disc_loss, psnr = train_step(lr, hr) gen_metric(gen_loss) disc_metric(disc_loss) psnr_metric(psnr) if step % hparams.print_steps == 0: - logging.info("Step: {}\tGenerator Loss: {}\tDiscriminator: {}\tPSNR: {}" - .format(step, gen_metric.result(), disc_metric.result(), - psnr_metric.result())) + logging.info("Step:%f\tGenerator Loss:%f\tDiscriminator:%f\tPSNR:%f", + step, gen_metric.result(), + disc_metric.result(), psnr_metric.result()) + val_step(lr, hr, step) # Modify the learning rate as mentioned in the paper. @@ -250,7 +249,7 @@ def val_step(image_lr, image_hr, step): phase_1_path=hparams.model_dir + '/Phase_1/generator', phase_2_path=hparams.model_dir + '/Phase_2/generator') - #Save interpolated generator + # Save interpolated generator os.makedirs(hparams.model_dir + '/Phase_2/interpolated_generator', exist_ok=True) interpolated_generator.save(hparams.model_dir diff --git a/tensorflow_gan/examples/esrgan/train_test.py b/tensorflow_gan/examples/esrgan/train_test.py index 14d67c0..63a1d85 100644 --- a/tensorflow_gan/examples/esrgan/train_test.py +++ b/tensorflow_gan/examples/esrgan/train_test.py @@ -15,7 +15,6 @@ """Tests for tfgan.examples.esrgan.train.""" -import collections import tensorflow as tf import train_lib @@ -24,7 +23,8 @@ class TrainTest(tf.test.TestCase): def setUp(self): - # Parameters for a single step of training. + # Parameters for a single step of training. + super(TrainTest, self).setUp() self.hparams = train_lib.HParams(32, 4, '/content/', False, False, 256, '/content/', 1, 11, 1, 1, @@ -41,7 +41,8 @@ def lr(hr): def test_pretrain_generator(self): """Executes all the processes inside the phase-1 training step, once.""" - self.assertIsNone(train_lib.pretrain_generator(self.hparams, self.mock_dataset)) + self.assertIsNone(train_lib.pretrain_generator(self.hparams, + self.mock_dataset)) def test_train_generator(self): """Executes the phase-2 training step for a single step, once.""" diff --git a/tensorflow_gan/examples/esrgan/utils.py b/tensorflow_gan/examples/esrgan/utils.py index 7569573..b1b265b 100644 --- a/tensorflow_gan/examples/esrgan/utils.py +++ b/tensorflow_gan/examples/esrgan/utils.py @@ -18,7 +18,6 @@ import os import tensorflow as tf import tensorflow_gan as tfgan -from absl import logging import PIL import numpy as np @@ -31,6 +30,12 @@ def preprocess_input(image): from the input images. This ensures that each feature will have a similar range and the gradients calculated during training are stable. + + Args: + image : Batch of tensors representing an image. + + Returns: + preprocessed images after subtracting the mean value. """ image = image[..., ::-1] mean = -tf.constant([103.939, 116.779, 123.68]) @@ -40,13 +45,12 @@ def preprocess_input(image): def visualize_results(image_lr, generated, image_hr, - size = 256, + size=256, image_dir='', step=0, train=True): - """Creates an image grid using Tf-GAN's image grid function and - saves the results as a .png image. + """Creates an image grid using Tf-GAN's image grid function. Args: image_lr : Batch of tensors representing LR images. @@ -76,15 +80,15 @@ def visualize_results(image_lr, os.makedirs(image_dir + 'training_results', exist_ok=True) result.save(image_dir + 'training_results/' + 'step_{}.png'.format(step)) else: - os.makedirs(image_dir + 'validation_results', exist_ok=True) - result.save(image_dir + 'validation_results/' + 'step_{}.png'.format(step)) + os.makedirs(image_dir + 'val_results', exist_ok=True) + result.save(image_dir + 'val_results/' + 'step_{}.png'.format(step)) def network_interpolation(alpha=0.2, phase_1_path=None, phase_2_path=None): - """Network interpolation as explained in section 3.4 in the paper, bascically - balancing the effects of PSNR oriented methods and GAN based methods. + """Network interpolation as explained in section 3.4 in the paper. + Args: alpha : interpolation parameter. phase_1_path : path to the network saved after phase 1 training. diff --git a/tensorflow_gan/examples/esrgan/utils_test.py b/tensorflow_gan/examples/esrgan/utils_test.py index d8f8129..5235a6b 100644 --- a/tensorflow_gan/examples/esrgan/utils_test.py +++ b/tensorflow_gan/examples/esrgan/utils_test.py @@ -36,13 +36,12 @@ def setUp(self): self.generator2 = networks.generator_network(self.hparams) self.generator1.save(self.hparams.path+'2/') - self.hr_data = tf.random.normal([2,256,256,3]) - self.lr_data = tf.random.normal([2,64,64,3]) - self.gen_data = tf.random.normal([2,256,256,3]) + self.hr_data = tf.random.normal([2, 256, 256, 3]) + self.lr_data = tf.random.normal([2, 64, 64, 3]) + self.gen_data = tf.random.normal([2, 256, 256, 3]) def test_visualize_results(self): - """ To test display grid function. The function doesn't return anything if no - error is found.""" + """To test display grid function.""" self.assertIsNone(utils.visualize_results(self.lr_data, self.gen_data, self.hr_data)) @@ -64,7 +63,7 @@ def test_inception_score(self): self.assertEqual(is_score.dtype, tf.float32) def test_interpolation(self): - """ To test the interpolation function.""" + """To test the interpolation function.""" inter_gen = utils.network_interpolation(phase_1_path=self.hparams.path+'1/', phase_2_path=self.hparams.path+'2/') self.assertEqual(type(inter_gen), type(self.generator1)) From 097cc2449f9963e7b2986cae126d0a7543be8b00 Mon Sep 17 00:00:00 2001 From: supertramp2 Date: Mon, 6 Sep 2021 13:09:56 +0530 Subject: [PATCH 20/20] Lint --- .../examples/esrgan/data_provider.py | 6 +- tensorflow_gan/examples/esrgan/networks.py | 131 +++++++++++------- 2 files changed, 84 insertions(+), 53 deletions(-) diff --git a/tensorflow_gan/examples/esrgan/data_provider.py b/tensorflow_gan/examples/esrgan/data_provider.py index 8e6591e..229c838 100644 --- a/tensorflow_gan/examples/esrgan/data_provider.py +++ b/tensorflow_gan/examples/esrgan/data_provider.py @@ -17,7 +17,6 @@ import tensorflow as tf import tensorflow_datasets as tfds -from tensorflow.python.data.experimental import AUTOTUNE def random_flip(lr_img, hr_img): @@ -56,6 +55,7 @@ def get_div2k_data(hparams, TypeError : If the data directory(data_dir) is not specified. """ split = 'train' if mode == 'train' else 'validation' + num_calls = tf.python.data.experimental.AUTOTUNE def scale(data): image = data['hr'] @@ -75,7 +75,7 @@ def scale(data): dataset = (tfds.load(name=name, split=split, data_dir=hparams.data_dir) - .map(scale, num_parallel_calls=AUTOTUNE) + .map(scale, num_parallel_calls=num_calls) .cache()) if shuffle: @@ -88,6 +88,6 @@ def scale(data): dataset = dataset.batch(hparams.batch_size) dataset = dataset.repeat(repeat_count) - dataset = dataset.prefetch(buffer_size=AUTOTUNE) + dataset = dataset.prefetch(buffer_size=num_calls) return dataset diff --git a/tensorflow_gan/examples/esrgan/networks.py b/tensorflow_gan/examples/esrgan/networks.py index 6a86d5b..a236082 100644 --- a/tensorflow_gan/examples/esrgan/networks.py +++ b/tensorflow_gan/examples/esrgan/networks.py @@ -21,46 +21,57 @@ """ import tensorflow as tf -from tensorflow.keras import layers def _conv_block(x, filters, activation=True): """Convolutional block used for building generator network.""" - h = layers.Conv2D(filters, kernel_size=[3, 3], - kernel_initializer="he_normal", bias_initializer="zeros", - strides=[1, 1], padding='same', use_bias=True)(x) + h = tf.keras.layers.Conv2D(filters, + kernel_size=[3, 3], + kernel_initializer="he_normal", + bias_initializer="zeros", + strides=[1, 1], + padding='same', + use_bias=True)(x) if activation: - h = layers.LeakyReLU(0.2)(h) + h = tf.keras.layers.LeakyReLU(0.2)(h) return h def _conv_block_d(x, out_channel): """Convolutional block used for building discriminator network.""" - x = layers.Conv2D(out_channel, 3, 1, padding='same', use_bias=False)(x) - x = layers.BatchNormalization(momentum=0.8)(x) - x = layers.LeakyReLU(alpha=0.2)(x) - - x = layers.Conv2D(out_channel, 4, 2, padding='same', use_bias=False)(x) - x = layers.BatchNormalization(momentum=0.8)(x) - x = layers.LeakyReLU(alpha=0.2)(x) + x = tf.keras.layers.Conv2D(out_channel, + kernel_size=3, + strides=1, + padding='same', + use_bias=False)(x) + x = tf.keras.layers.BatchNormalization(momentum=0.8)(x) + x = tf.keras.layers.LeakyReLU(alpha=0.2)(x) + + x = tf.keras.layers.Conv2D(out_channel, + kernel_size=4, + strides=2, + padding='same', + use_bias=False)(x) + x = tf.keras.layers.BatchNormalization(momentum=0.8)(x) + x = tf.keras.layers.LeakyReLU(alpha=0.2)(x) return x def dense_block(x): """Dense block used inside RRDB.""" h1 = _conv_block(x, 32) - h1 = layers.Concatenate()([x, h1]) + h1 = tf.keras.layers.Concatenate()([x, h1]) h2 = _conv_block(h1, 32) - h2 = layers.Concatenate()([x, h1, h2]) + h2 = tf.keras.layers.Concatenate()([x, h1, h2]) h3 = _conv_block(h2, 32) - h3 = layers.Concatenate()([x, h1, h2, h3]) + h3 = tf.keras.layers.Concatenate()([x, h1, h2, h3]) h4 = _conv_block(h3, 32) - h4 = layers.Concatenate()([x, h1, h2, h3, h4]) + h4 = tf.keras.layers.Concatenate()([x, h1, h2, h3, h4]) h5 = _conv_block(h4, 32, activation=False) - h5 = layers.Lambda(lambda x: x * 0.2)(h5) - h = layers.Add()([h5, x]) + h5 = tf.keras.layers.Lambda(lambda x: x * 0.2)(h5) + h = tf.keras.layers.Add()([h5, x]) return h @@ -69,16 +80,18 @@ def rrdb(x): h = dense_block(x) h = dense_block(h) h = dense_block(h) - h = layers.Lambda(lambda x: x * 0.2)(h) - out = layers.Add()([h, x]) + h = tf.keras.layers.Lambda(lambda x: x * 0.2)(h) + out = tf.keras.layers.Add()([h, x]) return out def upsample(x, filters): """Upsampling layer for the generator.""" - x = layers.Conv2DTranspose(filters, kernel_size=3, - strides=2, padding='same', - use_bias=True)(x) - x = layers.LeakyReLU(alpha=0.2)(x) + x = tf.keras.layers.Conv2DTranspose(filters, + kernel_size=3, + strides=2, + padding='same', + use_bias=True)(x) + x = tf.keras.layers.LeakyReLU(alpha=0.2)(x) return x def generator_network(hparams, @@ -97,30 +110,39 @@ def generator_network(hparams, inputs -> Batch of tensors representing LR images. outputs -> Batch of generated HR images. """ - lr_input = layers.Input(shape=(hparams.hr_dimension//hparams.scale, - hparams.hr_dimension//hparams.scale, 3)) + lr_input = tf.keras.layers.Input((hparams.hr_dimension//hparams.scale, + hparams.hr_dimension//hparams.scale, 3)) - x = layers.Conv2D(num_filters, kernel_size=[3, 3], strides=[1, 1], - padding='same', use_bias=True)(lr_input) - x = layers.LeakyReLU(0.2)(x) + x = tf.keras.layers.Conv2D(num_filters, kernel_size=[3, 3], strides=[1, 1], + padding='same', use_bias=True)(lr_input) + x = tf.keras.layers.LeakyReLU(0.2)(x) ref = x for _ in range(hparams.trunk_size): x = rrdb(x) - x = layers.Conv2D(num_filters, kernel_size=[3, 3], strides=[1, 1], - padding='same', use_bias=True)(x) - x = layers.Add()([x, ref]) + x = tf.keras.layers.Conv2D(num_filters, + kernel_size=[3, 3], + strides=[1, 1], + padding='same', + use_bias=True)(x) + x = tf.keras.layers.Add()([x, ref]) x = upsample(x, num_filters) x = upsample(x, num_filters) - x = layers.Conv2D(num_filters, kernel_size=[3, 3], strides=[1, 1], - padding='same', use_bias=True)(x) - x = layers.LeakyReLU(0.2)(x) - hr_output = layers.Conv2D(out_channels, kernel_size=[3, 3], strides=[1, 1], - padding='same', use_bias=True)(x) + x = tf.keras.layers.Conv2D(num_filters, + kernel_size=[3, 3], + strides=[1, 1], + padding='same', + use_bias=True)(x) + x = tf.keras.layers.LeakyReLU(0.2)(x) + hr_output = tf.keras.layers.Conv2D(out_channels, + kernel_size=[3, 3], + strides=[1, 1], + padding='same', + use_bias=True)(x) model = tf.keras.models.Model(inputs=lr_input, outputs=hr_output) return model @@ -137,24 +159,33 @@ def discriminator_network(hparams, num_filters=64): inputs -> Batch of tensors representing HR images. outputs -> Predictions for batch of input images. """ - img = layers.Input(shape=(hparams.hr_dimension, hparams.hr_dimension, 3)) - - x = layers.Conv2D(num_filters, [3, 3], 1, padding='same', use_bias=False)(img) - x = layers.BatchNormalization()(x) - x = layers.LeakyReLU(alpha=0.2)(x) - - x = layers.Conv2D(num_filters, [3, 3], 2, padding='same', use_bias=False)(x) - x = layers.BatchNormalization()(x) - x = layers.LeakyReLU(alpha=0.2)(x) + img = tf.keras.layers.Input(shape=(hparams.hr_dimension, + hparams.hr_dimension, 3)) + + x = tf.keras.layers.Conv2D(num_filters, + kernel_size=[3, 3], + strides=1, + padding='same', + use_bias=False)(img) + x = tf.keras.layers.BatchNormalization()(x) + x = tf.keras.layers.LeakyReLU(alpha=0.2)(x) + + x = tf.keras.layers.Conv2D(num_filters, + kernel_size=[3, 3], + strides=2, + padding='same', + use_bias=False)(x) + x = tf.keras.layers.BatchNormalization()(x) + x = tf.keras.layers.LeakyReLU(alpha=0.2)(x) x = _conv_block_d(x, num_filters *2) x = _conv_block_d(x, num_filters *4) x = _conv_block_d(x, num_filters *8) - x = layers.Flatten()(x) - x = layers.Dense(100)(x) - x = layers.LeakyReLU(alpha=0.2)(x) - x = layers.Dense(1)(x) + x = tf.keras.layers.Flatten()(x) + x = tf.keras.layers.Dense(100)(x) + x = tf.keras.layers.LeakyReLU(alpha=0.2)(x) + x = tf.keras.layers.Dense(1)(x) model = tf.keras.models.Model(inputs=img, outputs=x) return model

?3U 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