def __init__(self, nr_filters, kernel_initializer):
super(ResidualBlock,self).__init__()
#use padding to keep the featuremap size constant even after applying convolutions
self.padd1 = layers.ReflectionPadding2D()
#3x3 conv, normalization, relu, 3x3 conv, normalization, relu
self.conv_1 = tf.keras.layers.Conv2D(filters = nr_filters, kernel_size = 3,
kernel_initializer = kernel_initializer
#kernel_regularizer = tf.keras.regularizers.l2(0.01),
#padding = 'same'
)
#instance normalization
self.norm_1 = tf.keras.layers.BatchNormalization()
self.relu_1 = tf.keras.layers.ReLU()
self.padd2 = layers.ReflectionPadding2D()
self.conv_2 = tf.keras.layers.Conv2D(filters = nr_filters, kernel_size = 3,
kernel_initializer = kernel_initializer
# padding = 'same'
)
self.norm_2 = tf.keras.layers.BatchNormalization()
self.relu_2 = tf.keras.layers.ReLU()
def __init__(self):
super(Generator, self).__init__()
#structure as referenced by Zhu et al. (slight differences from Johnson architecture):
#c7s1-64,d128,d256,R256,R256,R256, R256,R256,R256,u128,u64,c7s1-3
#parameter for reflection padding before using a 7x7 kernel convolution
self.padds = 3
#Weights are initialized from a Gaussian distribution N(0, 0.02).
kernel_initializer = tf.random_normal_initializer(stddev=0.02)
#padd before using a 7x7 kernel as done in the first layer (Defined in strided block)
self.padd1 = layers.ReflectionPadding2D(padding=(self.padds, self.padds))
self.strided_block = [
#Johnson: 32 x9 x9 conv, stride 1 -> 32×128×128
#but in the cycle gan paper use 7x7, 64
DownsampleBlock(nr_filters =64, kernel_size = 7, stride = 1, padding = 'valid', kernel_initializer = kernel_initializer),
#Johnson: 64×3×3, conv, stride 2 -> 64×64×64
#Zhu: 128x3x3
DownsampleBlock(nr_filters =128, kernel_size = 3, stride = 2, padding = 'same',kernel_initializer = kernel_initializer),
#Johnson: 128×3×3 conv, stride 2 -> 128×32×32
#Zhu: 256
DownsampleBlock(nr_filters =256, kernel_size = 3, stride = 2, padding = 'same', kernel_initializer = kernel_initializer)
]
#Residual blocks -> 6 for 128x128 images (no padding in residual blocks: see text)
self.blocks = [
ResidualBlock(256, kernel_initializer = kernel_initializer),
ResidualBlock(256, kernel_initializer = kernel_initializer),
ResidualBlock(256, kernel_initializer = kernel_initializer),
ResidualBlock(256, kernel_initializer = kernel_initializer),
ResidualBlock(256, kernel_initializer = kernel_initializer),
ResidualBlock(256, kernel_initializer = kernel_initializer) # 32x32
]
self.transposed_block = [
#64×3×3 conv, stride 1/2 -> 64×64×64
UpsampleBlock(128,3,2, kernel_initializer),
#32×3×3 conv, stride 1/2 -> 32×128×128
UpsampleBlock(64,3,2, kernel_initializer),
]
#padding:
self.padd2 = layers.ReflectionPadding2D(padding=(self.padds, self.padds))
#3×9×9 conv, stride 1 3×128×128
self.final_layer = tf.keras.layers.Conv2D(filters=3, kernel_size=7,
strides =1, activation = tf.keras.activations.tanh,
padding = 'valid', kernel_initializer = kernel_initializer)
def __init__(self):
super(Generator, self).__init__()
#structure as referenced by Zhu et al. is different from Johnson architecture:
#Zhu: c7s1-64,d128,d256,R256,R256,R256, R256,R256,R256,u128,u64,c7s1-3
#Weights are initialized from a Gaussian distribution N(0, 0.02).
kernel_initializer = tf.random_normal_initializer(stddev=0.02)
#padd before using a 7x7 kernel as done in the first layer (Defined in strided block)
self.padd1 = layers.ReflectionPadding2D(padding=(40, 40))
self.strided_block = [
#Johnson: 32 x9 x9 conv, stride 1 -> 32× 208×208
#but in the cycle gan paper use 7x7, 64
DownsampleBlock(nr_filters =32, kernel_size = 9, stride = 1, padding = 'same', kernel_initializer = kernel_initializer),
#Johnson: 64×3×3, conv, stride 2 -> 64×104× 104
#Zhu: 128x3x3
DownsampleBlock(nr_filters = 64,kernel_size = 3, stride = 2, padding = 'same',kernel_initializer = kernel_initializer),
#Johnson: 128×3×3 conv, stride 2 -> 128×52x52
#Zhu: 256
DownsampleBlock(nr_filters =128, kernel_size = 3, stride = 2, padding = 'same', kernel_initializer = kernel_initializer)
]
#Residual blocks -> 5 in Johnson architecture
self.blocks = [
# -> 128 x 48 x48
ResidualBlock(128, kernel_initializer = kernel_initializer, size = 48),
# 128 x 44 x44
ResidualBlock(128, kernel_initializer = kernel_initializer, size = 44),
# 128 x 40x40
ResidualBlock(128, kernel_initializer = kernel_initializer, size = 40),
# 128 x 36 x 36
ResidualBlock(128, kernel_initializer = kernel_initializer, size = 36),
# 128 x 32 x32
ResidualBlock(128, kernel_initializer = kernel_initializer, size = 32),
]
self.transposed_block = [
#64×3×3 conv, stride 1/2 -> 64×64 x64
UpsampleBlock(64,3,2, kernel_initializer),
#32×3×3 conv, stride 1/2 -> 32×128×128
UpsampleBlock(32,3,2, kernel_initializer),
]
#padding:
#self.padd2 = layers.ReflectionPadding2D(padding=(self.padds, self.padds))
#3×9×9 conv, stride 1 3×128×128
#Johnson et al. use tanh
self.final_layer = tf.keras.layers.Conv2D(filters=3, kernel_size=9,
strides =1, activation = tf.keras.activations.tanh,
padding = 'same', kernel_initializer = kernel_initializer)
def __init__(self, nr_filters, kernel_initializer):
super(ResidualBlock, self).__init__()
#use padding to keep the featuremap size constant even after applying convolutions
self.padd1 = layers.ReflectionPadding2D()
#3x3 conv, normalization, relu, 3x3 conv, instance normalization, relu
self.conv_1 = tf.keras.layers.Conv2D(
filters=nr_filters,
kernel_size=3,
kernel_initializer=kernel_initializer
#kernel_regularizer = tf.keras.regularizers.l2(0.01),
#padding = 'same'
)
#Instancenorm normalizes the feature channels of each image of a batch seperatly along
#its spatial dimensions. The gamma_initializer sets the initial weights of the layer
#to a normla distribution with mean at 0 and standard deviation at 0.02.
self.norm_1 = tfa.layers.InstanceNormalization(
gamma_initializer=tf.keras.initializers.RandomNormal(mean=0.0,
stddev=0.02))
self.relu_1 = tf.keras.layers.ReLU()
self.padd2 = layers.ReflectionPadding2D()
self.conv_2 = tf.keras.layers.Conv2D(
filters=nr_filters,
kernel_size=3,
kernel_initializer=kernel_initializer
# padding = 'same'
)
self.norm_2 = tfa.layers.InstanceNormalization(
gamma_initializer=tf.keras.initializers.RandomNormal(mean=0.0,
stddev=0.02))
self.relu_2 = tf.keras.layers.ReLU()
def image_transform_net(img_width, img_height, tv_weight=1):
x = Input(shape=(img_width, img_height, 3), name="input")
a = layers.InputNormalize()(x)
a = layers.ReflectionPadding2D(padding=(40, 40),
input_shape=(img_width, img_height, 3))(a)
a = layers.conv_bn_relu(32, 9, 9, stride=(1, 1))(a)
a = layers.conv_bn_relu(64, 9, 9, stride=(2, 2))(a)
a = layers.conv_bn_relu(128, 3, 3, stride=(2, 2))(a)
for _ in range(5):
a = layers.res_conv(128, 3, 3)(a)
a = layers.dconv_bn_nolinear(64, 3, 3)(a)
a = layers.dconv_bn_nolinear(64, 3, 3)(a)
a = layers.conv_bn_relu(3, 9, 9, stride=(1, 1), relu=False)(a)
y = layers.Denormalize(name='transform_output')(a)
model = Model(inputs=x, outputs=y)
if tv_weight > 0:
add_total_variation_loss(model.layers[-1], tv_weight)
return model