def __init__(self, latent_dim, condition_dim):
# prepare latent vector (noise) input
generator_input1 = layers.Input(shape=(latent_dim, ))
x1 = layers.Dense(1024)(generator_input1)
x1 = layers.Activation('tanh')(x1)
x1 = layers.Dense(128 * 7 * 7)(x1)
x1 = layers.BatchNormalization()(x1)
x1 = layers.Activation('tanh')(x1)
x1 = layers.Reshape((7, 7, 128))(x1)
# prepare conditional input
generator_input2 = layers.Input(shape=(condition_dim, ))
x2 = layers.Dense(1024)(generator_input2)
x2 = layers.Activation('tanh')(x2)
x2 = layers.Dense(128 * 7 * 7)(x2)
x2 = layers.BatchNormalization()(x2)
x2 = layers.Activation('tanh')(x2)
x2 = layers.Reshape((7, 7, 128))(x2)
# concatenate 2 inputs
generator_input = layers.Concatenate()([x1, x2])
x = layers.UpSampling2D(size=(2, 2))(generator_input)
x = layers.Conv2D(64, 5, padding='same')(x)
x = layers.Activation('tanh')(x)
x = layers.UpSampling2D(size=(2, 2))(x)
x = layers.Conv2D(1, 5, padding='same')(x)
x = layers.Activation('tanh')(x)
self.generator = tf.keras.models.Model(inputs=[generator_input1, generator_input2], outputs=x)
def define_model(self):
z = Input(shape=[self.model_parameters.latent_size])
x = layers.Dense(units=8 * 8 * 256, use_bias=False)(z)
x = layers.BatchNormalization()(x)
x = layers.LeakyReLU()(x)
x = layers.Reshape((8, 8, 256))(x)
x = layers.Conv2D(128, (5, 5),
strides=(1, 1),
padding='same',
use_bias=False)(x)
x = layers.BatchNormalization()(x)
x = layers.LeakyReLU()(x)
x = layers.UpSampling2D()(x)
x = layers.Conv2D(64, (5, 5),
strides=(1, 1),
padding='same',
use_bias=False)(x)
x = layers.BatchNormalization()(x)
x = layers.LeakyReLU()(x)
x = layers.UpSampling2D()(x)
x = layers.Conv2D(3, (5, 5),
strides=(1, 1),
padding='same',
use_bias=False,
activation='tanh')(x)
model = Model(name=self.model_name, inputs=z, outputs=x)
return model
def __init__(self, out_channels=256, **kwargs):
'''
Feature Pyramid Networks
Attributes
---
out_channels: int. the channels of pyramid feature maps.
'''
super(FPN, self).__init__(**kwargs)
self.out_channels = out_channels
self.fpn_c2p2 = layers.Conv2D(out_channels, (1, 1),
kernel_initializer='he_normal',
name='fpn_c2p2')
self.fpn_c3p3 = layers.Conv2D(out_channels, (1, 1),
kernel_initializer='he_normal',
name='fpn_c3p3')
self.fpn_c4p4 = layers.Conv2D(out_channels, (1, 1),
kernel_initializer='he_normal',
name='fpn_c4p4')
self.fpn_c5p5 = layers.Conv2D(out_channels, (1, 1),
kernel_initializer='he_normal',
name='fpn_c5p5')
self.fpn_p3upsampled = layers.UpSampling2D(size=(2, 2),
name='fpn_p3upsampled')
self.fpn_p4upsampled = layers.UpSampling2D(size=(2, 2),
name='fpn_p4upsampled')
self.fpn_p5upsampled = layers.UpSampling2D(size=(2, 2),
name='fpn_p5upsampled')
self.fpn_p2 = layers.Conv2D(out_channels, (3, 3),
padding='SAME',
kernel_initializer='he_normal',
name='fpn_p2')
self.fpn_p3 = layers.Conv2D(out_channels, (3, 3),
padding='SAME',
kernel_initializer='he_normal',
name='fpn_p3')
self.fpn_p4 = layers.Conv2D(out_channels, (3, 3),
padding='SAME',
kernel_initializer='he_normal',
name='fpn_p4')
self.fpn_p5 = layers.Conv2D(out_channels, (3, 3),
padding='SAME',
kernel_initializer='he_normal',
name='fpn_p5')
self.fpn_p6 = layers.MaxPooling2D(pool_size=(1, 1),
strides=2,
name='fpn_p6')
def make_generator_model(input_tensor=None,
input_shape=(noise_dim,)):
"""
Returns:
tf.keras.Model
"""
if input_tensor is None:
img_input = layers.Input(shape=input_shape)
else:
if not backend.is_keras_tensor(input_tensor):
img_input = layers.Input(tensor=input_tensor, shape=input_shape)
else:
img_input = input_tensor
x = layers.Dense(7 * 7 * 256,
activation=tf.nn.relu,
use_bias=False,
name='fc1')(img_input)
x = layers.Reshape(target_shape=(7, 7, 128), name='reshape1')(x)
x = layers.BatchNormalization(momentum=0.8, name='bn1')(x)
x = layers.UpSampling2D(name='upsampling1')(x)
x = layers.Conv2D(128, (3, 3),
activation=tf.nn.relu,
padding="same",
use_bias=False,
name='conv1')(x)
x = layers.BatchNormalization(momentum=0.8, name='bn2')(x)
x = layers.UpSampling2D(name='upsampling2')(x)
x = layers.Conv2D(64, (3, 3),
activation=tf.nn.relu,
padding="same",
use_bias=False,
name='conv2')(x)
x = layers.BatchNormalization(momentum=0.8, name='bn3')(x)
x = layers.Conv2D(1, (3, 3),
activation=tf.nn.tanh,
use_bias=False,
name='conv3')(x)
noise = layers.Input(shape=(noise_dim,))
label = layers.Input(shape=(1,), dtype='int32')
label_embedding = layers.Flatten()(layers.Embedding(num_classes, 100)(label))
x = layers.multiply([noise, label_embedding])(x)
return models.Model([noise, label], x)
def RetinaNet(input_shape, num_classes, num_anchor=9):
"""Creates the RetinaNet.
RetinaNet is composed of an FPN, a classification sub-network and a localization regression sub-network.
Args:
input_shape (tuple): shape of input image.
num_classes (int): number of classes.
num_anchor (int, optional): number of anchor boxes. Defaults to 9.
Returns:
'Model' object: RetinaNet.
"""
inputs = tf.keras.Input(shape=input_shape)
# FPN
resnet50 = tf.keras.applications.ResNet50(weights="imagenet", include_top=False, input_tensor=inputs, pooling=None)
assert resnet50.layers[80].name == "conv3_block4_out"
C3 = resnet50.layers[80].output
assert resnet50.layers[142].name == "conv4_block6_out"
C4 = resnet50.layers[142].output
assert resnet50.layers[-1].name == "conv5_block3_out"
C5 = resnet50.layers[-1].output
P5 = layers.Conv2D(256, kernel_size=1, strides=1, padding='same')(C5)
P5_upsampling = layers.UpSampling2D()(P5)
P4 = layers.Conv2D(256, kernel_size=1, strides=1, padding='same')(C4)
P4 = layers.Add()([P5_upsampling, P4])
P4_upsampling = layers.UpSampling2D()(P4)
P3 = layers.Conv2D(256, kernel_size=1, strides=1, padding='same')(C3)
P3 = layers.Add()([P4_upsampling, P3])
P6 = layers.Conv2D(256, kernel_size=3, strides=2, padding='same', name="P6")(C5)
P7 = layers.Activation('relu')(P6)
P7 = layers.Conv2D(256, kernel_size=3, strides=2, padding='same', name="P7")(P7)
P5 = layers.Conv2D(256, kernel_size=3, strides=1, padding='same', name="P5")(P5)
P4 = layers.Conv2D(256, kernel_size=3, strides=1, padding='same', name="P4")(P4)
P3 = layers.Conv2D(256, kernel_size=3, strides=1, padding='same', name="P3")(P3)
# classification subnet
cls_subnet = classification_sub_net(num_classes=num_classes, num_anchor=num_anchor)
P3_cls = cls_subnet(P3)
P4_cls = cls_subnet(P4)
P5_cls = cls_subnet(P5)
P6_cls = cls_subnet(P6)
P7_cls = cls_subnet(P7)
cls_output = layers.Concatenate(axis=-2)([P3_cls, P4_cls, P5_cls, P6_cls, P7_cls])
# localization subnet
loc_subnet = regression_sub_net(num_anchor=num_anchor)
P3_loc = loc_subnet(P3)
P4_loc = loc_subnet(P4)
P5_loc = loc_subnet(P5)
P6_loc = loc_subnet(P6)
P7_loc = loc_subnet(P7)
loc_output = layers.Concatenate(axis=-2)([P3_loc, P4_loc, P5_loc, P6_loc, P7_loc])
return tf.keras.Model(inputs=inputs, outputs=[cls_output, loc_output])
def _decoder_block_last(self, num_filters, inputs, strides=(2, 2)):
features, encoder_out = inputs
upsample = layers.UpSampling2D(size=strides)(encoder_out)
conv_1 = self._conv_block(num_filters, upsample)
concat = layers.Concatenate(axis=-1)([conv_1, features])
conv_2 = self._conv_block(num_filters * 2, concat)
return conv_2
def dsv_block(input_layers, num_filters, scale_factor):
dsv = layers.Conv2D(num_filters,
kernel_size=1,
strides=1,
kernel_initializer=initializer,
padding="same")(input_layers)
dsv = layers.UpSampling2D(size=scale_factor, interpolation='bilinear')(dsv)
return dsv
def __init__(self, latent_dim):
generator_input = tf.keras.Input(shape=(latent_dim,))
x = layers.Dense(1024)(generator_input)
x = layers.Activation('tanh')(x)
x = layers.Dense(128*7*7)(x)
x = layers.BatchNormalization()(x)
x = layers.Activation('tanh')(x)
x = layers.Reshape((7, 7, 128))(x)
x = layers.UpSampling2D(size=(2, 2))(x)
x = layers.Conv2D(64, 5, padding='same')(x)
x = layers.Activation('tanh')(x)
x = layers.UpSampling2D(size=(2, 2))(x)
x = layers.Conv2D(1, 5, padding='same')(x)
x = layers.Activation('tanh')(x)
self.generator = tf.keras.models.Model(generator_input, x)
def _decoder_block(self, num_filters, inputs, strides=(2, 2)):
features, encoder_out = inputs
upsample = layers.UpSampling2D(size=strides)(encoder_out)
conv_1 = self._conv_block(num_filters, upsample)
concat = layers.Concatenate(axis=-1)([conv_1, features])
conv_2 = self._conv_block(num_filters, concat)
conv_3 = layers.Conv2D(num_filters, (1, 1), padding='same')(conv_2)
output = layers.LeakyReLU(alpha=0.01)(
InstanceNormalization(axis=-1)(conv_3))
return output
def upsampling1d(x, size=2):
"""
Args:
x: input_tensor (N, L)
size: int
Returns: tensor (N, L*ks)
"""
_x = tf.expand_dims(x, axis=2)
_x = kl.UpSampling2D((size, 1))(_x)
_x = tf.squeeze(_x, axis=2)
return _x
def define_model(self):
z = Input(shape=[self.model_parameters.latent_size])
class_id = Input(shape=[1])
embedded_id = layers.Embedding(input_dim=10, output_dim=50)(class_id)
embedded_id = layers.Dense(units=7 * 7)(embedded_id)
embedded_id = layers.Reshape(target_shape=(7, 7, 1))(embedded_id)
x = layers.Dense(units=7 * 7 * 256, use_bias=False)(z)
x = layers.BatchNormalization()(x)
x = layers.LeakyReLU()(x)
x = layers.Reshape((7, 7, 256))(x)
inputs = layers.Concatenate(axis=3)([x, embedded_id])
x = layers.Conv2D(128, (5, 5),
strides=(1, 1),
padding='same',
use_bias=False)(inputs)
x = layers.BatchNormalization()(x)
x = layers.LeakyReLU()(x)
x = layers.UpSampling2D()(x)
x = layers.Conv2D(64, (5, 5),
strides=(1, 1),
padding='same',
use_bias=False)(x)
x = layers.BatchNormalization()(x)
x = layers.LeakyReLU()(x)
x = layers.UpSampling2D()(x)
x = layers.Conv2D(1, (5, 5),
strides=(1, 1),
padding='same',
use_bias=False,
activation='tanh')(x)
model = Model(name=self.model_name, inputs=[z, class_id], outputs=x)
return model
def __init__(self,filter:int, **kwargs):
super(AttnGatingBlock, self).__init__()
self.theta_x = layers.Conv2D(filter, kernel_size=(2,2), strides=(2, 2), **kwargs)
self.phi_g = layers.Conv2D(filter, kernel_size=(1,1), **kwargs)
self.deconv_g = layers.Conv2DTranspose(filter, kernel_size=(3,3), strides=(1,1), **kwargs)
self.act_xg = layers.Activation('relu')
self.conv = layers.Conv2D(1, kernel_size=(1,1), **kwargs)
self.act_sigmoid = layers.Activation('sigmoid')
self.upsample = layers.UpSampling2D()
self.conv_end = layers.Conv2D(filter, kernel_size=(1, 1), **kwargs)
self.bn = layers.BatchNormalization()
def define_generator(latent_dim=50, nclasses=10):
label = layers.Input(shape=(1, ))
li = layers.Embedding(nclasses, latent_dim)(label)
li = layers.Flatten()(li)
noise = layers.Input(shape=(latent_dim, ))
input = layers.multiply([li, noise])
x = layers.Dense(7*7*128, activation="relu")(input)
x = layers.Reshape((7, 7, 128))(x)
x = layers.BatchNormalization(momentum=0.8)(x)
x = layers.UpSampling2D()(x)
x = layers.Conv2D(filters=128, kernel_size=3, padding="same", activation="relu")(x)
x = layers.BatchNormalization(momentum=0.8)(x)
x = layers.UpSampling2D()(x)
x = layers.Conv2D(filters=64, kernel_size=3, padding="same", activation="relu")(x)
x = layers.BatchNormalization(momentum=0.8)(x)
out = layers.Conv2D(filters=1, kernel_size=3, padding="same", activation="tanh")(x)
model = tf.keras.Model([noise, label], out)
return model
def _forward(self, level, inp, var_scope, is_train):
# Upper branch
up1 = inp
up1 = self._modules['b1_' + str(level)](
up1,
256,
256,
var_scope=var_scope + "_ConvBlock_b1_level_%d" % level,
is_train=is_train)
# Lower branch
low1 = layers.AveragePooling2D(pool_size=(2, 2),
strides=2,
name=var_scope +
'_AvgPool2D_level_%d' % level)(inp)
low1 = self._modules['b2_' + str(level)](
low1,
256,
256,
var_scope=var_scope + "_ConvBlock_b2_level_%d" % level,
is_train=is_train)
if level > 1:
low2 = self._forward(level - 1,
low1,
var_scope=var_scope +
'_forward_level_%d' % level,
is_train=is_train)
else:
low2 = low1
low2 = self._modules['b2_plus_' + str(level)](
low2,
256,
256,
var_scope=var_scope + "_ConvBlock_b2_plus_level_%d" % level,
is_train=is_train)
low3 = low2
low3 = self._modules['b3_' + str(level)](
low3,
256,
256,
var_scope=var_scope + "_ConvBlock_b3_level_%d" % level,
is_train=is_train)
up2 = layers.UpSampling2D(size=(2, 2),
name=var_scope + '_UpSample2D')(low3)
return up1 + up2
def build(self):
inputs = layers.Input(self.input_size)
output0 = self._context_module(16, inputs, strides=(1, 1))
output1 = self._context_module(32, output0, strides=(2, 2))
output2 = self._context_module(64, output1, strides=(2, 2))
output3 = self._context_module(128, output2, strides=(2, 2))
output4 = self._context_module(256, output3, strides=(2, 2))
decoder0 = self._decoder_block(128, [output3, output4])
decoder1 = self._decoder_block(64, [output2, decoder0])
decoder2 = self._decoder_block(32, [output1, decoder1])
decoder3 = self._decoder_block_last(16, [output0, decoder2])
output0 = layers.Conv2D(self.num_class, (1, 1))(decoder3)
output1 = layers.Conv2D(self.num_class, (1, 1))(decoder2)
output2_up = layers.UpSampling2D(size=(2, 2))(layers.Conv2D(
self.num_class, (1, 1))(decoder1))
output_sum = layers.Add()([output2_up, output1])
output_sum = layers.UpSampling2D(size=(2, 2))(output_sum)
output_sum = layers.Add()([output_sum, output0])
output = layers.Softmax()(output_sum)
return models.Model(inputs=[inputs], outputs=[output])
def yolov3(input_size, anchors=yolo_anchors, num_classes=80, iou_threshold=0.5, score_threshold=0.5, training=False):
"""Create YOLO_V3 model CNN body in Keras."""
num_anchors = len(anchors) // 3
inputs = Input(input_size)
x_26, x_43, x = darknet_body(name='Yolo_DarkNet')(inputs)
x, y1 = make_last_layers(x, 512, num_anchors, num_classes)
x = darknetconv2d_bn_leaky(x, 256, (1, 1))
x = layers.UpSampling2D(2)(x)
x = layers.Concatenate()([x, x_43])
x, y2 = make_last_layers(x, 256, num_anchors, num_classes)
x = darknetconv2d_bn_leaky(x, 128, (1, 1))
x = layers.UpSampling2D(2)(x)
x = layers.Concatenate()([x, x_26])
x, y3 = make_last_layers(x, 128, num_anchors, num_classes)
h, w, _ = input_size
y1 = YoloOutputBoxLayer(anchors[6:], 1, num_classes, training)(y1)
y2 = YoloOutputBoxLayer(anchors[3:6], 2, num_classes, training)(y2)
y3 = YoloOutputBoxLayer(anchors[0:3], 3, num_classes, training)(y3)
if training:
return Model(inputs, (y1, y2, y3), name='Yolo-V3')
outputs = NMSLayer(num_classes, iou_threshold, score_threshold)([y1, y2, y3])
return Model(inputs, outputs, name='Yolo-V3')
def decoder_block(num_filers, conv1, conv2):
up = layers.concatenate([layers.UpSampling2D(size=(2, 2))(conv1), conv2],
axis=-1)
# to reduce checkerboard effect
conv = layers.Conv2D(num_filers, (3, 3),
padding='same',
kernel_initializer=VarianceScaling())(up)
conv = layers.BatchNormalization()(conv)
conv = layers.Activation('relu')(conv)
conv = layers.Conv2D(num_filers, (3, 3),
padding='same',
kernel_initializer=VarianceScaling())(conv)
conv = layers.BatchNormalization()(conv)
conv = layers.Activation('relu')(conv)
return conv
def yolov3_tiny(input_size, anchors=yolo_tiny_anchors, num_classes=80, iou_threshold=0.5, score_threshold=0.5, training=False):
num_anchors = len(anchors) // 3
inputs = Input(input_size)
x1 = darknetconv2d_bn_leaky(inputs, 16, (3, 3))
x1 = layers.MaxPooling2D(pool_size=(2, 2), strides=(2, 2), padding='same')(x1)
x1 = darknetconv2d_bn_leaky(x1, 32, (3, 3))
x1 = layers.MaxPooling2D(pool_size=(2, 2), strides=(2, 2), padding='same')(x1)
x1 = darknetconv2d_bn_leaky(x1, 64, (3, 3))
x1 = layers.MaxPooling2D(pool_size=(2, 2), strides=(2, 2), padding='same')(x1)
x1 = darknetconv2d_bn_leaky(x1, 128, (3, 3))
x1 = layers.MaxPooling2D(pool_size=(2, 2), strides=(2, 2), padding='same')(x1)
x1 = darknetconv2d_bn_leaky(x1, 256, (3, 3))
x2 = layers.MaxPooling2D(pool_size=(2, 2), strides=(2, 2), padding='same')(x1)
x2 = darknetconv2d_bn_leaky(x2, 512, (3, 3))
x2 = layers.MaxPooling2D(pool_size=(2, 2), strides=(1, 1), padding='same')(x2)
x2 = darknetconv2d_bn_leaky(x2, 1024, (3, 3))
x2 = darknetconv2d_bn_leaky(x2, 256, (1, 1))
# make last layer 1
y1 = darknetconv2d_bn_leaky(x2, 512, (3, 3))
y1 = darknetconv2d(y1, num_anchors*(num_classes+5), (1, 1))
y1 = YoloOutputLayer(num_anchors, num_classes)(y1)
# Up Sampling
x2 = darknetconv2d_bn_leaky(x2, 128, (1, 1))
x2 = layers.UpSampling2D(2)(x2)
# make last layer 2
y2 = layers.Concatenate()([x2, x1])
y2 = darknetconv2d_bn_leaky(y2, 256, (3, 3))
y2 = darknetconv2d(y2, num_anchors*(num_classes+5), (1, 1))
y2 = YoloOutputLayer(num_anchors, num_classes)(y2)
h, w, _ = input_size
y1 = YoloOutputBoxLayer(anchors[3:], 1, num_classes, training)(y1)
y2 = YoloOutputBoxLayer(anchors[:3], 2, num_classes, training)(y2)
if training:
return Model(inputs, (y1, y2), name='Yolo-V3')
outputs = NMSLayer(num_classes, iou_threshold, score_threshold)([y1, y2])
return Model(inputs, outputs, name='Yolo-V3')
def call(self, x):
if self.npath == 1:
out = x
for j in range(self.nsublayer):
out = getattr(self, f"conv{i+1}_{j+1}")(self.relu(out))
out += x
else:
assert isinstance(x, (list, tuple))
maxh = tf.reduce_max([xi.shape[-2] for xi in x])
maxw = tf.reduce_max([xi.shape[-1] for xi in x])
out = 0
for i in range(self.npath):
outi = x[i]
for j in range(self.nsublayer):
outi = getattr(self, f"conv{i+1}_{j+1}")(self.relu(outi))
outi += x[i]
assert maxh % out.shape[-2] == 0
assert maxw % out.shape[-1] == 0
upsample_size = (maxh / xi.shape[-2], maxw / xi.shape[-1])
if upsample_size != (1, 1):
self.upsample = layers.UpSampling2D(upsample_size, "channels_first", interpolation="bilinear")
outi = self.upsample(outi)
out += outi
return out
def _decode_layer(self, vertical_input, horizontal_input, filter_num,
filter_size):
upu3a = layers.UpSampling2D(size=(2, 2))(vertical_input)
convu3a = layers.Conv2DTranspose(
filter_num, (2, 2),
strides=1,
padding="same",
activation='relu',
kernel_initializer=xavier_initializer_conv2d())(upu3a)
convu3b = layers.concatenate(inputs=[horizontal_input, convu3a],
axis=3)
convu3c = layers.Conv2D(
filter_num,
filter_size,
activation='relu',
padding="same",
kernel_initializer=xavier_initializer_conv2d())(convu3b)
convu3d = layers.Conv2D(
filter_num,
filter_size,
activation='relu',
padding="same",
kernel_initializer=xavier_initializer_conv2d())(convu3c)
return convu3d
def YOLOv4(inputs,
num_classes,
num_anchors,
initial_filters=32,
fast=False,
anchors=None,
conf_thresh=0.05,
nms_thresh=0.45,
keep_top_k=100,
nms_top_k=100):
i32 = initial_filters
i64 = i32 * 2
i128 = i32 * 4
i256 = i32 * 8
i512 = i32 * 16
i1024 = i32 * 32
if fast:
# x = PreLayer()(inputs)
x = inputs
else:
x = inputs
# cspdarknet53部分
x = conv2d_unit(x, i32, 3, strides=1, padding='same')
# ============================= s2 =============================
x = layers.ZeroPadding2D(padding=((1, 0), (1, 0)))(x)
x = conv2d_unit(x, i64, 3, strides=2)
s2 = conv2d_unit(x, i64, 1, strides=1)
x = conv2d_unit(x, i64, 1, strides=1)
x = stack_residual_block(x, i32, i64, n=1)
x = conv2d_unit(x, i64, 1, strides=1)
x = layers.Concatenate()([x, s2])
x = conv2d_unit(x, i64, 1, strides=1)
# ============================= s4 =============================
x = layers.ZeroPadding2D(padding=((1, 0), (1, 0)))(x)
x = conv2d_unit(x, i128, 3, strides=2)
s4 = conv2d_unit(x, i64, 1, strides=1)
x = conv2d_unit(x, i64, 1, strides=1)
x = stack_residual_block(x, i64, i64, n=2)
x = conv2d_unit(x, i64, 1, strides=1)
x = layers.Concatenate()([x, s4])
x = conv2d_unit(x, i128, 1, strides=1)
# ============================= s8 =============================
x = layers.ZeroPadding2D(padding=((1, 0), (1, 0)))(x)
x = conv2d_unit(x, i256, 3, strides=2)
s8 = conv2d_unit(x, i128, 1, strides=1)
x = conv2d_unit(x, i128, 1, strides=1)
x = stack_residual_block(x, i128, i128, n=8)
x = conv2d_unit(x, i128, 1, strides=1)
s8 = layers.Concatenate()([x, s8])
x = conv2d_unit(s8, i256, 1, strides=1)
# ============================= s16 =============================
x = layers.ZeroPadding2D(padding=((1, 0), (1, 0)))(x)
x = conv2d_unit(x, i512, 3, strides=2)
s16 = conv2d_unit(x, i256, 1, strides=1)
x = conv2d_unit(x, i256, 1, strides=1)
x = stack_residual_block(x, i256, i256, n=8)
x = conv2d_unit(x, i256, 1, strides=1)
s16 = layers.Concatenate()([x, s16])
x = conv2d_unit(s16, i512, 1, strides=1)
# ============================= s32 =============================
x = layers.ZeroPadding2D(padding=((1, 0), (1, 0)))(x)
x = conv2d_unit(x, i1024, 3, strides=2)
s32 = conv2d_unit(x, i512, 1, strides=1)
x = conv2d_unit(x, i512, 1, strides=1)
x = stack_residual_block(x, i512, i512, n=4)
x = conv2d_unit(x, i512, 1, strides=1)
x = layers.Concatenate()([x, s32])
x = conv2d_unit(x, i1024, 1, strides=1)
# cspdarknet53部分结束
# fpn部分
x = conv2d_unit(x, i512, 1, strides=1, act='leaky')
x = conv2d_unit(x, i1024, 3, strides=1, padding='same', act='leaky')
x = conv2d_unit(x, i512, 1, strides=1, act='leaky')
x = spp(x)
x = conv2d_unit(x, i512, 1, strides=1, act='leaky')
x = conv2d_unit(x, i1024, 3, strides=1, padding='same', act='leaky')
fpn_s32 = conv2d_unit(x, i512, 1, strides=1, act='leaky')
x = conv2d_unit(fpn_s32, i256, 1, strides=1, act='leaky')
x = layers.UpSampling2D(2)(x)
s16 = conv2d_unit(s16, i256, 1, strides=1, act='leaky')
x = layers.Concatenate()([s16, x])
x = conv2d_unit(x, i256, 1, strides=1, act='leaky')
x = conv2d_unit(x, i512, 3, strides=1, padding='same', act='leaky')
x = conv2d_unit(x, i256, 1, strides=1, act='leaky')
x = conv2d_unit(x, i512, 3, strides=1, padding='same', act='leaky')
fpn_s16 = conv2d_unit(x, i256, 1, strides=1, act='leaky')
x = conv2d_unit(fpn_s16, i128, 1, strides=1, act='leaky')
x = layers.UpSampling2D(2)(x)
s8 = conv2d_unit(s8, i128, 1, strides=1, act='leaky')
x = layers.Concatenate()([s8, x])
# output_s
x = conv2d_unit(x, i128, 1, strides=1, act='leaky')
x = conv2d_unit(x, i256, 3, strides=1, padding='same', act='leaky')
x = conv2d_unit(x, i128, 1, strides=1, act='leaky')
x = conv2d_unit(x, i256, 3, strides=1, padding='same', act='leaky')
x = conv2d_unit(x, i128, 1, strides=1, act='leaky')
output_s = conv2d_unit(x, i256, 3, strides=1, padding='same', act='leaky')
output_s = conv2d_unit(output_s,
num_anchors * (num_classes + 5),
1,
strides=1,
bn=0,
act=None)
# output_m
x = layers.ZeroPadding2D(padding=((1, 0), (1, 0)))(x)
x = conv2d_unit(x, i256, 3, strides=2, act='leaky')
x = layers.Concatenate()([x, fpn_s16])
x = conv2d_unit(x, i256, 1, strides=1, act='leaky')
x = conv2d_unit(x, i512, 3, strides=1, padding='same', act='leaky')
x = conv2d_unit(x, i256, 1, strides=1, act='leaky')
x = conv2d_unit(x, i512, 3, strides=1, padding='same', act='leaky')
x = conv2d_unit(x, i256, 1, strides=1, act='leaky')
output_m = conv2d_unit(x, i512, 3, strides=1, padding='same', act='leaky')
output_m = conv2d_unit(output_m,
num_anchors * (num_classes + 5),
1,
strides=1,
bn=0,
act=None)
# output_l
x = layers.ZeroPadding2D(padding=((1, 0), (1, 0)))(x)
x = conv2d_unit(x, i512, 3, strides=2, act='leaky')
x = layers.Concatenate()([x, fpn_s32])
x = conv2d_unit(x, i512, 1, strides=1, act='leaky')
x = conv2d_unit(x, i1024, 3, strides=1, padding='same', act='leaky')
x = conv2d_unit(x, i512, 1, strides=1, act='leaky')
x = conv2d_unit(x, i1024, 3, strides=1, padding='same', act='leaky')
x = conv2d_unit(x, i512, 1, strides=1, act='leaky')
output_l = conv2d_unit(x, i1024, 3, strides=1, padding='same', act='leaky')
output_l = conv2d_unit(output_l,
num_anchors * (num_classes + 5),
1,
strides=1,
bn=0,
act=None)
# 用张量操作实现后处理
if fast:
def output_layer(args):
output_s, output_m, output_l = args
# 先对坐标解码
pred_xywh_s, pred_conf_s, pred_prob_s = decode(
output_s, anchors[0], 8, num_classes)
pred_xywh_m, pred_conf_m, pred_prob_m = decode(
output_m, anchors[1], 16, num_classes)
pred_xywh_l, pred_conf_l, pred_prob_l = decode(
output_l, anchors[2], 32, num_classes)
# 获取分数
pred_score_s = pred_conf_s * pred_prob_s
pred_score_m = pred_conf_m * pred_prob_m
pred_score_l = pred_conf_l * pred_prob_l
# 所有输出层的预测框集合后再执行nms
all_pred_boxes = tf.concat([pred_xywh_s, pred_xywh_m, pred_xywh_l],
axis=1) # [batch_size, -1, 4]
all_pred_scores = tf.concat(
[pred_score_s, pred_score_m, pred_score_l],
axis=1) # [batch_size, -1, 80]
# 用fastnms
output = fastnms(all_pred_boxes, all_pred_scores, conf_thresh,
nms_thresh, keep_top_k, nms_top_k)
return output
output = layers.Lambda(output_layer)([output_s, output_m, output_l])
model_body = keras.models.Model(inputs=inputs, outputs=output)
else:
model_body = keras.models.Model(inputs=inputs,
outputs=[output_l, output_m, output_s])
return model_body
def create_model(self):
input_images = Input(shape=[self.img_height, self.img_width, self.num_channels])
x1 = layers.Conv2D(
filters=64,
kernel_size=(7, 7),
strides=(2, 2),
padding='same',
use_bias=False,
)(input_images)
x1 = tfa.layers.InstanceNormalization()(x1)
x1 = layers.ReLU()(x1)
x2 = layers.Conv2D(
filters=128,
kernel_size=(3, 3),
strides=(2, 2),
padding='same',
use_bias=False,
)(x1)
x2 = tfa.layers.InstanceNormalization()(x2)
x2 = layers.ReLU()(x2)
x3 = layers.Conv2D(
filters=256,
kernel_size=(3, 3),
strides=(2, 2),
padding='same',
use_bias=False,
)(x2)
x3 = tfa.layers.InstanceNormalization()(x3)
x3 = layers.ReLU()(x3)
x4 = layers.Conv2D(
filters=512,
kernel_size=(3, 3),
strides=(2, 2),
padding='same',
use_bias=False,
)(x3)
x4 = tfa.layers.InstanceNormalization()(x4)
x4 = layers.ReLU()(x4)
x5 = layers.UpSampling2D()(x4)
x5 = layers.Concatenate()([x5, x3])
x5 = layers.Conv2D(
filters=256,
kernel_size=(3, 3),
strides=(1, 1),
padding='same',
use_bias=False,
)(x5)
x5 = tfa.layers.InstanceNormalization()(x5)
x5 = layers.LeakyReLU(alpha=0.2)(x5)
x6 = layers.UpSampling2D()(x5)
x6 = layers.Concatenate()([x6, x2])
x6 = layers.Conv2D(
filters=128,
kernel_size=(3, 3),
strides=(1, 1),
padding='same',
use_bias=False,
)(x6)
x6 = tfa.layers.InstanceNormalization()(x6)
x6 = layers.LeakyReLU(alpha=0.2)(x6)
x7 = layers.UpSampling2D()(x6)
x7 = layers.Concatenate()([x7, x1])
x7 = layers.Conv2D(
filters=64,
kernel_size=(3, 3),
strides=(1, 1),
padding='same',
use_bias=False,
)(x7)
x7 = tfa.layers.InstanceNormalization()(x7)
x7 = layers.LeakyReLU(alpha=0.2)(x7)
x8 = layers.UpSampling2D()(x7)
x8 = layers.Concatenate()([x8, input_images])
x8 = layers.Conv2D(
filters=32,
kernel_size=(3, 3),
strides=(1, 1),
padding='same',
use_bias=False,
)(x8)
x8 = tfa.layers.InstanceNormalization()(x8)
x8 = layers.LeakyReLU(alpha=0.2)(x8)
x9 = layers.Conv2D(
filters=3,
kernel_size=(5, 5),
strides=(1, 1),
padding='same',
use_bias=False,
activation='tanh',
)(x8)
model = Model(name='Generator', inputs=input_images, outputs=x9)
return model
def RetinaNet(input_shape, num_classes, num_anchor=9):
inputs = tf.keras.Input(shape=input_shape)
# FPN
resnet50 = tf.keras.applications.ResNet50(weights="imagenet", include_top=False, input_tensor=inputs, pooling=None)
assert resnet50.layers[80].name == "conv3_block4_out"
C3 = resnet50.layers[80].output
assert resnet50.layers[142].name == "conv4_block6_out"
C4 = resnet50.layers[142].output
assert resnet50.layers[-1].name == "conv5_block3_out"
C5 = resnet50.layers[-1].output
P5 = layers.Conv2D(256, kernel_size=1, strides=1, padding='same', kernel_regularizer=regularizers.l2(0.0001))(C5)
P5_upsampling = layers.UpSampling2D()(P5)
P4 = layers.Conv2D(256, kernel_size=1, strides=1, padding='same', kernel_regularizer=regularizers.l2(0.0001))(C4)
P4 = layers.Add()([P5_upsampling, P4])
P4_upsampling = layers.UpSampling2D()(P4)
P3 = layers.Conv2D(256, kernel_size=1, strides=1, padding='same', kernel_regularizer=regularizers.l2(0.0001))(C3)
P3 = layers.Add()([P4_upsampling, P3])
P6 = layers.Conv2D(256,
kernel_size=3,
strides=2,
padding='same',
name="P6",
kernel_regularizer=regularizers.l2(0.0001))(C5)
P7 = layers.Activation('relu')(P6)
P7 = layers.Conv2D(256,
kernel_size=3,
strides=2,
padding='same',
name="P7",
kernel_regularizer=regularizers.l2(0.0001))(P7)
P5 = layers.Conv2D(256,
kernel_size=3,
strides=1,
padding='same',
name="P5",
kernel_regularizer=regularizers.l2(0.0001))(P5)
P4 = layers.Conv2D(256,
kernel_size=3,
strides=1,
padding='same',
name="P4",
kernel_regularizer=regularizers.l2(0.0001))(P4)
P3 = layers.Conv2D(256,
kernel_size=3,
strides=1,
padding='same',
name="P3",
kernel_regularizer=regularizers.l2(0.0001))(P3)
# classification subnet
cls_subnet = _classification_sub_net(num_classes=num_classes, num_anchor=num_anchor)
P3_cls = cls_subnet(P3)
P4_cls = cls_subnet(P4)
P5_cls = cls_subnet(P5)
P6_cls = cls_subnet(P6)
P7_cls = cls_subnet(P7)
cls_output = layers.Concatenate(axis=-2)([P3_cls, P4_cls, P5_cls, P6_cls, P7_cls])
# localization subnet
loc_subnet = _regression_sub_net(num_anchor=num_anchor)
P3_loc = loc_subnet(P3)
P4_loc = loc_subnet(P4)
P5_loc = loc_subnet(P5)
P6_loc = loc_subnet(P6)
P7_loc = loc_subnet(P7)
loc_output = layers.Concatenate(axis=-2)([P3_loc, P4_loc, P5_loc, P6_loc, P7_loc])
return tf.keras.Model(inputs=inputs, outputs=[cls_output, loc_output])
h1 = layers.Conv2D(16, 3, activation=tf.nn.relu)(encode_input)
h1 = layers.Conv2D(32, 3, activation=tf.nn.relu)(h1)
h1 = layers.MaxPool2D(3)(h1)
h1 = layers.Conv2D(32, 3, activation='relu')(h1)
h1 = layers.Conv2D(16, 3, activation='relu')(h1)
encode_output = layers.GlobalMaxPool2D()(h1)
encode_model = tf.keras.Model(inputs=encode_input,
outputs=encode_output,
name='encoder')
encode_model.summary()
decode_input = tf.keras.Input(shape=(16, ), name='encoded_img')
h2 = layers.Reshape((4, 4, 1))(decode_input)
h2 = layers.Conv2DTranspose(16, 3, activation='relu')(h2)
h2 = layers.Conv2DTranspose(32, 3, activation='relu')(h2)
h2 = layers.UpSampling2D(3)(h2)
h2 = layers.Conv2DTranspose(16, 3, activation='relu')(h2)
decode_output = layers.Conv2DTranspose(1, 3, activation='relu')(h2)
decode_model = tf.keras.Model(inputs=decode_input,
outputs=decode_output,
name='decoder')
decode_model.summary()
autoencoder_input = tf.keras.Input(shape=(28, 28, 1), name='img')
h3 = encode_model(autoencoder_input)
autoencoder_output = decode_model(h3)
autoencoder = tf.keras.Model(inputs=autoencoder_input,
outputs=autoencoder_output,
name='autoencoder')
autoencoder.summary()
def get_model():
img_height = 256
img_width = 256
img_channels = 1
input_shape = (img_height, img_width, img_channels)
img_input = tf.keras.Input(shape=input_shape)
conv1 = layers.Conv2D(64,
3,
activation='relu',
padding='same',
kernel_initializer='he_normal')(img_input)
conv1 = layers.Conv2D(64,
3,
activation='relu',
padding='same',
kernel_initializer='he_normal')(conv1)
pool1 = layers.MaxPooling2D(pool_size=(2, 2))(conv1)
conv2 = layers.Conv2D(128,
3,
activation='relu',
padding='same',
kernel_initializer='he_normal')(pool1)
conv2 = layers.Conv2D(128,
3,
activation='relu',
padding='same',
kernel_initializer='he_normal')(conv2)
pool2 = layers.MaxPooling2D(pool_size=(2, 2))(conv2)
conv3 = layers.Conv2D(256,
3,
activation='relu',
padding='same',
kernel_initializer='he_normal')(pool2)
conv3 = layers.Conv2D(256,
3,
activation='relu',
padding='same',
kernel_initializer='he_normal')(conv3)
pool3 = layers.MaxPooling2D(pool_size=(2, 2))(conv3)
conv4 = layers.Conv2D(512,
3,
activation='relu',
padding='same',
kernel_initializer='he_normal')(pool3)
conv4 = layers.Conv2D(512,
3,
activation='relu',
padding='same',
kernel_initializer='he_normal')(conv4)
drop4 = layers.Dropout(0.5)(conv4)
pool4 = layers.MaxPooling2D(pool_size=(2, 2))(drop4)
conv5 = layers.Conv2D(1024,
3,
activation='relu',
padding='same',
kernel_initializer='he_normal')(pool4)
conv5 = layers.Conv2D(1024,
3,
activation='relu',
padding='same',
kernel_initializer='he_normal')(conv5)
drop5 = layers.Dropout(0.5)(conv5)
up6 = layers.Conv2D(512,
2,
activation='relu',
padding='same',
kernel_initializer='he_normal')(
layers.UpSampling2D(size=(2, 2))(drop5))
merge6 = layers.concatenate([drop4, up6])
conv6 = layers.Conv2D(512,
3,
activation='relu',
padding='same',
kernel_initializer='he_normal')(merge6)
conv6 = layers.Conv2D(512,
3,
activation='relu',
padding='same',
kernel_initializer='he_normal')(conv6)
up7 = layers.Conv2D(256,
2,
activation='relu',
padding='same',
kernel_initializer='he_normal')(
layers.UpSampling2D(size=(2, 2))(conv6))
merge7 = layers.concatenate([conv3, up7])
conv7 = layers.Conv2D(256,
3,
activation='relu',
padding='same',
kernel_initializer='he_normal')(merge7)
conv7 = layers.Conv2D(256,
3,
activation='relu',
padding='same',
kernel_initializer='he_normal')(conv7)
up8 = layers.Conv2D(128,
2,
activation='relu',
padding='same',
kernel_initializer='he_normal')(
layers.UpSampling2D(size=(2, 2))(conv7))
cv1 = layers.Conv2D(128,
2,
activation='relu',
padding='same',
kernel_initializer='he_normal')(up8)
merge8 = layers.concatenate([conv2, up8])
conv8 = layers.Conv2D(128,
3,
activation='relu',
padding='same',
kernel_initializer='he_normal')(merge8)
conv8 = layers.Conv2D(128,
3,
activation='relu',
padding='same',
kernel_initializer='he_normal')(conv8)
up9 = layers.Conv2D(64,
2,
activation='relu',
padding='same',
kernel_initializer='he_normal')(
layers.UpSampling2D(size=(2, 2))(conv8))
merge9 = layers.concatenate([conv1, up9])
conv9 = layers.Conv2D(64,
3,
activation='relu',
padding='same',
kernel_initializer='he_normal')(merge9)
conv9 = layers.Conv2D(64,
3,
activation='relu',
padding='same',
kernel_initializer='he_normal')(conv9)
conv9 = layers.Conv2D(2,
3,
activation='relu',
padding='same',
kernel_initializer='he_normal')(conv9)
conv10 = layers.Conv2D(1, 1, activation='sigmoid')(conv9)
model = models.Model(img_input, conv10)
return model
def create_model(self):
# inputs = Input(shape=[self.max_sequence_length, self.embedding_size])
z = Input(shape=[self.hidden_size])
captions = Input(shape=self.max_sequence_length)
embeddings = layers.Embedding(self.vocab_size,
self.embedding_size)(captions)
embeddings = attention.multihead_attention_model(embeddings)
embeddings = layers.Flatten()(embeddings)
embeddings = layers.Dense(units=8 * 8 * 32, use_bias=False)(embeddings)
embeddings = layers.BatchNormalization()(embeddings)
embeddings = layers.LeakyReLU()(embeddings)
embeddings = layers.Reshape((8, 8, 32))(embeddings)
x = layers.Dense(units=8 * 8 * 256, use_bias=False)(z)
x = layers.BatchNormalization()(x)
x = layers.ReLU()(x)
x = layers.Reshape((8, 8, 256))(x)
x = layers.Concatenate(axis=3)([x, embeddings])
x = layers.UpSampling2D()(x)
x = layers.Conv2D(
filters=512,
kernel_size=(3, 3),
strides=(1, 1),
padding='same',
use_bias=False,
)(x)
x = layers.BatchNormalization()(x)
x = layers.ReLU()(x)
x = layers.UpSampling2D()(x)
x = layers.Conv2D(
filters=256,
kernel_size=(3, 3),
strides=(1, 1),
padding='same',
use_bias=False,
)(x)
x = layers.BatchNormalization()(x)
x = layers.ReLU()(x)
n_resnet = 6
for _ in range(n_resnet):
x = resnet_block(256, x)
x = layers.UpSampling2D()(x)
x = layers.Conv2D(
filters=256,
kernel_size=(3, 3),
strides=(1, 1),
padding='same',
use_bias=False,
)(x)
x = layers.BatchNormalization()(x)
x = layers.ReLU()(x)
x = layers.UpSampling2D()(x)
x = layers.Conv2D(
filters=128,
kernel_size=(3, 3),
strides=(1, 1),
padding='same',
use_bias=False,
)(x)
x = layers.BatchNormalization()(x)
x = layers.ReLU()(x)
x = layers.UpSampling2D()(x)
x = layers.Conv2D(
filters=64,
kernel_size=(3, 3),
strides=(1, 1),
padding='same',
use_bias=False,
)(x)
x = layers.BatchNormalization()(x)
x = layers.ReLU()(x)
x = layers.Conv2D(
filters=3,
kernel_size=(3, 3),
strides=(1, 1),
padding='same',
use_bias=False,
activation='tanh',
)(x)
# model = Model(name='Generator', inputs=z, outputs=x)
model = Model(name='Generator', inputs=[z, captions], outputs=x)
return model
def upsample_block(x):
u = layers.UpSampling2D((2, 2))(x)
return u
def upsample5_concat_block(x, xskip): # concatenates a decoder output with and encoder output of same size
u = layers.UpSampling2D((5, 5))(x)# image dimensions are multiplied by 2
c = layers.Concatenate()([u, xskip])
return c
def define_model(self):
input_images = Input(shape=[
self.model_parameters.img_height, self.model_parameters.img_width,
self.model_parameters.num_channels
])
x = layers.Conv2D(
filters=64,
kernel_size=(7, 7),
padding='same',
use_bias=False,
)(input_images)
x = tfa.layers.InstanceNormalization()(x)
x = layers.ReLU()(x)
x = layers.Conv2D(
filters=128,
kernel_size=(3, 3),
strides=(2, 2),
padding='same',
use_bias=False,
)(x)
x = tfa.layers.InstanceNormalization()(x)
x = layers.ReLU()(x)
x = layers.Conv2D(
filters=256,
kernel_size=(3, 3),
strides=(2, 2),
padding='same',
use_bias=False,
)(x)
x = layers.Conv2D(
filters=256,
kernel_size=(3, 3),
strides=(2, 2),
padding='same',
use_bias=False,
)(x)
n_resnet = 6
for _ in range(n_resnet):
x = advanced_layers.residual_block(256, x)
x = layers.UpSampling2D()(x)
x = layers.Conv2D(
filters=128,
kernel_size=(3, 3),
strides=(1, 1),
padding='same',
use_bias=False,
)(x)
x = tfa.layers.InstanceNormalization()(x)
x = layers.ReLU()(x)
x = layers.UpSampling2D()(x)
x = layers.Conv2D(
filters=128,
kernel_size=(3, 3),
strides=(1, 1),
padding='same',
use_bias=False,
)(x)
x = tfa.layers.InstanceNormalization()(x)
x = layers.ReLU()(x)
x = layers.UpSampling2D()(x)
x = layers.Conv2D(
filters=64,
kernel_size=(3, 3),
strides=(1, 1),
padding='same',
use_bias=False,
)(x)
x = tfa.layers.InstanceNormalization()(x)
x = layers.ReLU()(x)
x = layers.Conv2D(
filters=32,
kernel_size=(5, 5),
strides=(1, 1),
padding='same',
use_bias=False,
)(x)
x = tfa.layers.InstanceNormalization()(x)
x = layers.ReLU()(x)
x = layers.Conv2D(
filters=3,
kernel_size=(7, 7),
strides=(1, 1),
padding='same',
use_bias=False,
activation='tanh',
)(x)
model = Model(name=self.model_name, inputs=input_images, outputs=x)
return model
def define_model(self):
input_images = Input(shape=[
self.model_parameters.img_height, self.model_parameters.img_width,
self.model_parameters.num_channels
])
x1 = layers.Conv2D(
filters=64,
kernel_size=(7, 7),
strides=(2, 2),
padding='same',
use_bias=False,
)(input_images)
x1 = tfa.layers.InstanceNormalization()(x1)
x1 = layers.ReLU()(x1)
x2 = layers.Conv2D(
filters=128,
kernel_size=(3, 3),
strides=(2, 2),
padding='same',
use_bias=False,
)(x1)
x2 = tfa.layers.InstanceNormalization()(x2)
x2 = layers.ReLU()(x2)
x3 = layers.Conv2D(
filters=256,
kernel_size=(3, 3),
strides=(2, 2),
padding='same',
use_bias=False,
)(x2)
x3 = tfa.layers.InstanceNormalization()(x3)
x3 = layers.ReLU()(x3)
x4 = advanced_layers.densely_connected_residual_block(x3)
x5 = layers.Concatenate()([x4, x3])
x5 = layers.Conv2D(
filters=256,
kernel_size=(3, 3),
strides=(1, 1),
padding='same',
use_bias=False,
)(x5)
x5 = tfa.layers.InstanceNormalization()(x5)
x5 = layers.LeakyReLU(alpha=0.2)(x5)
x6 = layers.UpSampling2D()(x5)
x6 = layers.Concatenate()([x6, x2])
x6 = layers.Conv2D(
filters=128,
kernel_size=(3, 3),
strides=(1, 1),
padding='same',
use_bias=False,
)(x6)
x6 = tfa.layers.InstanceNormalization()(x6)
x6 = layers.LeakyReLU(alpha=0.2)(x6)
x7 = layers.UpSampling2D()(x6)
x7 = layers.Concatenate()([x7, x1])
x7 = layers.Conv2D(
filters=64,
kernel_size=(3, 3),
strides=(1, 1),
padding='same',
use_bias=False,
)(x7)
x7 = tfa.layers.InstanceNormalization()(x7)
x7 = layers.LeakyReLU(alpha=0.2)(x7)
x8 = layers.UpSampling2D()(x7)
x8 = layers.Concatenate()([x8, input_images])
x8 = layers.Conv2D(
filters=32,
kernel_size=(3, 3),
strides=(1, 1),
padding='same',
use_bias=False,
)(x8)
x8 = tfa.layers.InstanceNormalization()(x8)
x8 = layers.LeakyReLU(alpha=0.2)(x8)
x9 = layers.Conv2D(
filters=3,
kernel_size=(5, 5),
strides=(1, 1),
padding='same',
use_bias=False,
activation='tanh',
)(x8)
model = Model(name=self.model_name, inputs=input_images, outputs=x9)
return model
