def get_G(a_shape=(None, flags.za_dim), c_shape=(None, flags.c_shape[0], flags.c_shape[1], flags.c_shape[2]), \
name=None):
ndf = 256
na = Input(a_shape)
nc = Input(c_shape)
#z = Concat(-1)([na, nt])
z = na
nz = ExpandDims(1)(z)
nz = ExpandDims(1)(nz)
nz = Tile([1, c_shape[1], c_shape[2], 1])(nz)
# res block
nn = Conv2d(ndf, (3, 3), (1, 1), act=None, W_init=w_init, b_init=None)(nc)
nn = InstanceNorm2d(act=tf.nn.relu, gamma_init=g_init)(nn)
nn = Conv2d(ndf, (3, 3), (1, 1), act=None, W_init=w_init, b_init=None)(nn)
nn = InstanceNorm2d(act=None, gamma_init=g_init)(nn)
n = Elementwise(tf.add)([nc, nn])
nd_tmp = flags.za_dim
ndf = ndf + nd_tmp
n = Concat(-1)([n, nz])
# res block *3
for i in range(1, 4):
nn = Conv2d(ndf, (3, 3), (1, 1), act=None, W_init=w_init,
b_init=None)(n)
nn = InstanceNorm2d(act=tf.nn.relu, gamma_init=g_init)(nn)
nn = Conv2d(ndf, (3, 3), (1, 1), act=None, W_init=w_init,
b_init=None)(nn)
nn = InstanceNorm2d(act=None, gamma_init=g_init)(nn)
n = Elementwise(tf.add)([n, nn])
for i in range(2):
ndf = ndf + nd_tmp
n = Concat(-1)([n, nz])
nz = Tile([1, 2, 2, 1])(nz)
n = DeConv2d(ndf // 2, (3, 3), (2, 2),
act=tf.nn.relu,
W_init=w_init,
b_init=None)(n)
n = InstanceNorm2d(act=tf.nn.relu, gamma_init=g_init)(n)
ndf = ndf // 2
n = Concat(-1)([n, nz])
n = DeConv2d(3, (1, 1), (1, 1), act=tf.nn.tanh, W_init=w_init)(n)
M = Model(inputs=[na, nc], outputs=n, name=name)
return M
def get_discriminator(latent_shape, image_shape, df_dim=64):
w_init = tf.random_normal_initializer(stddev=0.02)
gamma_init = tf.random_normal_initializer(1., 0.02)
lrelu = lambda x: tf.nn.leaky_relu(x, 0.2)
n1i = Input(image_shape)
n1 = Conv2d(df_dim, (5, 5), (2, 2), act=lrelu, W_init=w_init)(n1i)
n1 = Conv2d(df_dim * 2, (5, 5), (2, 2), W_init=w_init, b_init=None)(n1)
n1 = BatchNorm2d(decay=0.9, act=lrelu, gamma_init=gamma_init)(n1)
n1 = Dropout(keep=0.8)(n1)
n1 = Conv2d(df_dim * 4, (5, 5), (2, 2), W_init=w_init, b_init=None)(n1)
n1 = BatchNorm2d(decay=0.9, act=lrelu, gamma_init=gamma_init)(n1)
n1 = Dropout(keep=0.8)(n1)
n1 = Conv2d(df_dim * 8, (5, 5), (2, 2), W_init=w_init, b_init=None)(n1)
n1 = BatchNorm2d(decay=0.9, act=lrelu, gamma_init=gamma_init)(n1)
n1 = Dropout(keep=0.8)(n1)
n1 = Flatten()(n1) # [-1,4*4*df_dim*8]
n2i = Input(latent_shape)
n2 = Dense(n_units=4 * 4 * df_dim * 8, W_init=w_init, b_init=None)(n2i)
n2 = Dropout(keep=0.8)(n2)
nn = Concat()([n1, n2])
nn = Dense(n_units=1, W_init=w_init, b_init=None)(nn)
return tl.models.Model(inputs=[n1i, n2i], outputs=nn, name='discriminator')
def tam_net(self):
inputs = Input(self.in_shape, name='inputs')
e_in = inputs
for i in range(0, 5):
e_out = Conv2d(self.f_size * (2**i), (3, 3), (2, 2),
act=tf.nn.relu,
name=f'e{i+1}_con')(e_in)
e_in = self.residual_block(i, e=True)(e_out)
self.__setattr__(f'e{i+1}', e_in)
d_in = e_in
for i in range(4, 0, -1):
d_out = DeConv2d(self.f_size * (2**(i - 1)), (3, 3), (2, 2),
name=f'd{i}_con')(d_in)
encoder = self.__getattribute__(f'e{i}')
d_out = Concat(concat_dim=3, name=f'concat{i}')([encoder, d_out])
d_out = Conv2d(self.f_size * (2**(i - 1)), (1, 1), (1, 1),
name=f'fusion{i}')(d_out)
d_in = self.residual_block(i - 1, e=False)(d_out)
self.__setattr__(f'd{i + 1}', d_in)
outs = DeConv2d(3, (3, 3), (2, 2), name='d_con_out')(d_in)
outs = Conv2d(3, (1, 1), (1, 1), act=tf.nn.sigmoid, name='outs')(outs)
return Model(inputs=inputs, outputs=outs, name="TAM_Net")
def fire_block(n, n_filter, max_pool=False, name='fire_block'):
n = Conv2d(n_filter, (1, 1), (1, 1), tf.nn.relu, 'SAME', name=name + '.squeeze1x1')(n)
n1 = Conv2d(n_filter * 4, (1, 1), (1, 1), tf.nn.relu, 'SAME', name=name + '.expand1x1')(n)
n2 = Conv2d(n_filter * 4, (3, 3), (1, 1), tf.nn.relu, 'SAME', name=name + '.expand3x3')(n)
n = Concat(-1, name=name + '.concat')([n1, n2])
if max_pool:
n = MaxPool2d((3, 3), (2, 2), 'VALID', name=name + '.max')(n)
return n
def u_net(self):
inputs = Input(self.in_shape, name='inputs')
conv1 = Conv2d(64, (3, 3), act=tf.nn.relu, name='conv1_1')(inputs)
conv1 = Conv2d(64, (3, 3), act=tf.nn.relu, name='conv1_2')(conv1)
pool1 = MaxPool2d((2, 2), name='pool1')(conv1)
conv2 = Conv2d(128, (3, 3), act=tf.nn.relu, name='conv2_1')(pool1)
conv2 = Conv2d(128, (3, 3), act=tf.nn.relu, name='conv2_2')(conv2)
pool2 = MaxPool2d((2, 2), name='pool2')(conv2)
conv3 = Conv2d(256, (3, 3), act=tf.nn.relu, name='conv3_1')(pool2)
conv3 = Conv2d(256, (3, 3), act=tf.nn.relu, name='conv3_2')(conv3)
pool3 = MaxPool2d((2, 2), name='pool3')(conv3)
conv4 = Conv2d(512, (3, 3), act=tf.nn.relu, name='conv4_1')(pool3)
conv4 = Conv2d(512, (3, 3), act=tf.nn.relu, name='conv4_2')(conv4)
pool4 = MaxPool2d((2, 2), name='pool4')(conv4)
conv5 = Conv2d(1024, (3, 3), act=tf.nn.relu, name='conv5_1')(pool4)
conv5 = Conv2d(1024, (3, 3), act=tf.nn.relu, name='conv5_2')(conv5)
up4 = DeConv2d(512, (3, 3), (2, 2), name='deconv4')(conv5)
up4 = Concat(3, name='concat4')([up4, conv4])
conv4 = Conv2d(512, (3, 3), act=tf.nn.relu, name='uconv4_1')(up4)
conv4 = Conv2d(512, (3, 3), act=tf.nn.relu, name='uconv4_2')(conv4)
up3 = DeConv2d(256, (3, 3), (2, 2), name='deconv3')(conv4)
up3 = Concat(3, name='concat3')([up3, conv3])
conv3 = Conv2d(256, (3, 3), act=tf.nn.relu, name='uconv3_1')(up3)
conv3 = Conv2d(256, (3, 3), act=tf.nn.relu, name='uconv3_2')(conv3)
up2 = DeConv2d(128, (3, 3), (2, 2), name='deconv2')(conv3)
up2 = Concat(3, name='concat2')([up2, conv2])
conv2 = Conv2d(128, (3, 3), act=tf.nn.relu, name='uconv2_1')(up2)
conv2 = Conv2d(128, (3, 3), act=tf.nn.relu, name='uconv2_2')(conv2)
up1 = DeConv2d(64, (3, 3), (2, 2), name='deconv1')(conv2)
up1 = Concat(3, name='concat1')([up1, conv1])
conv1 = Conv2d(64, (3, 3), act=tf.nn.relu, name='uconv1_1')(up1)
conv1 = Conv2d(64, (3, 3), act=tf.nn.relu, name='uconv1_2')(conv1)
outs = Conv2d(3, (1, 1), act=tf.nn.sigmoid, name='uconv1')(conv1)
return Model(inputs=inputs, outputs=outs, name="U_Net")
def model_G2(): ##Phase2 Generator
gamma_init = tf1.random_normal_initializer(1., 0.02)
w_init = tf1.random_normal_initializer(stddev=0.02)
fn = tf1.nn.relu
## Input layers
lr_image = Input(
(None, 128, 128, 3)) ## (batch_size, height, width, channel)
hr_image = Input((None, 512, 512, 3))
## Feature extracting layers from LR image
lr_feature_layer_1 = Conv2d(64, (3, 3), (1, 1),
act=fn,
padding='SAME',
W_init=w_init)(lr_image) # Shape(1,256,256,64)
lr_feature_layer_1 = BatchNorm2d(gamma_init=gamma_init)(lr_feature_layer_1)
lr_feature_layer_2 = SubpixelConv2d(scale=4, act=fn)(
lr_feature_layer_1) # Shape(1,256,256,16)
## Feature extracting layers from HR image
hr_feature_layer_1 = Conv2d(64, (3, 3), (1, 1),
act=fn,
padding='SAME',
W_init=w_init)(hr_image) # Shape(1,256,256,64)
hr_feature_layer_1 = BatchNorm2d(gamma_init=gamma_init)(hr_feature_layer_1)
## Features Merging layers
merge_layer = Concat(concat_dim=-1)(
[lr_feature_layer_2, hr_feature_layer_1]) # Shape(1,256,256,128)
non_linearity_layer_1 = Conv2d(64, (5, 5), (1, 1),
act=fn,
padding='SAME',
W_init=w_init)(
merge_layer) # Shape(1,256,256,256)
non_linearity_layer_1 = BatchNorm2d(
gamma_init=gamma_init)(non_linearity_layer_1)
## Reconstruction layers
Recon_layer_1 = Conv2d(3, (5, 5), (1, 1),
act=fn,
padding='SAME',
W_init=w_init)(
non_linearity_layer_1) # Shape(1,256,256,1)
Recon_layer_2 = Elementwise(combine_fn=tf1.add)([Recon_layer_1, hr_image
]) # Shape(1,256,256,1)
return Model(inputs=[lr_image, hr_image], outputs=Recon_layer_2)
def get_dwG(
shape_z=(None, 100),
shape_h=(0, 16)): # Dimension of gen filters in first conv layer. [64]
s16 = flags.img_size_h // 16
gf_dim = 64 # Dimension of gen filters in first conv layer. [64]
w_init = tf.random_normal_initializer(stddev=0.02)
gamma_init = tf.random_normal_initializer(1., 0.02)
n_z = Input(shape_z)
n_h = Input(shape_h)
n = Concat(-1)([n_z, n_h])
n = Dense(n_units=(gf_dim * 8 * s16 * s16),
W_init=w_init,
act=tf.identity,
b_init=None)(n)
n = Reshape(shape=[-1, s16, s16, gf_dim * 8])(n)
n = BatchNorm(decay=0.9, act=tf.nn.relu, gamma_init=gamma_init)(n)
n = DeConv2d(gf_dim * 4, (5, 5),
strides=(2, 2),
act=None,
W_init=w_init,
b_init=None)(n)
n = BatchNorm(decay=0.9, act=tf.nn.relu, gamma_init=gamma_init)(n)
n = DeConv2d(gf_dim * 2, (5, 5),
strides=(2, 2),
act=None,
W_init=w_init,
b_init=None)(n)
n = BatchNorm(decay=0.9, act=tf.nn.relu, gamma_init=gamma_init)(n)
n = DeConv2d(gf_dim, (5, 5),
strides=(2, 2),
act=None,
W_init=w_init,
b_init=None)(n)
n = BatchNorm(decay=0.9, act=tf.nn.relu, gamma_init=gamma_init)(n)
n = DeConv2d(flags.c_dim, (5, 5),
strides=(2, 2),
act=tf.nn.tanh,
W_init=w_init)(n)
return tl.models.Model(inputs=[n_z, n_h], outputs=n, name='generator')
def unet(ni, out_channel, is_tanh, out_size=flags.img_size_h):
w_init = tf.random_normal_initializer(stddev=0.02)
gamma_init = tf.random_normal_initializer(1., 0.02)
ngf = 64
conv1 = Conv2d(ngf, (3, 3), (1, 1), W_init=w_init, act=lrelu)(ni)
conv2 = Conv2d(ngf, (4, 4), (2, 2), W_init=w_init, act=None,
b_init=None)(conv1)
conv2 = BatchNorm2d(decay=0.9, act=lrelu, gamma_init=gamma_init,
name=None)(conv2)
conv3 = Conv2d(ngf * 2, (4, 4), (1, 1),
W_init=w_init,
act=None,
b_init=None)(conv2)
conv3 = BatchNorm2d(decay=0.9, act=lrelu, gamma_init=gamma_init,
name=None)(conv3)
conv4 = Conv2d(ngf * 2, (4, 4), (2, 2),
W_init=w_init,
act=None,
b_init=None)(conv3)
conv4 = BatchNorm2d(decay=0.9, act=lrelu, gamma_init=gamma_init,
name=None)(conv4)
conv5 = Conv2d(ngf * 4, (4, 4), (1, 1),
W_init=w_init,
act=None,
b_init=None)(conv4)
conv5 = BatchNorm2d(decay=0.9, act=lrelu, gamma_init=gamma_init,
name=None)(conv5)
conv6 = Conv2d(ngf * 4, (4, 4), (2, 2),
W_init=w_init,
act=None,
b_init=None)(conv5)
conv6 = BatchNorm2d(decay=0.9, act=lrelu, gamma_init=gamma_init,
name=None)(conv6)
conv7 = Conv2d(ngf * 8, (4, 4), (1, 1),
W_init=w_init,
act=None,
b_init=None)(conv6)
conv7 = BatchNorm2d(decay=0.9, act=lrelu, gamma_init=gamma_init,
name=None)(conv7)
conv8 = Conv2d(ngf * 8, (4, 4), (2, 2),
act=lrelu,
W_init=w_init,
b_init=None)(conv7)
# 8 8 512 now start upsample
c_size = conv8.shape[-2]
##############################################################################################
no = None
for _ in range(1):
up8 = DeConv2d(ngf * 8, (4, 4), (2, 2), W_init=w_init,
b_init=None)(conv8)
up8 = BatchNorm2d(decay=0.9,
act=lrelu,
gamma_init=gamma_init,
name=None)(up8)
up7 = Concat(concat_dim=3)([up8, conv7])
up7 = DeConv2d(ngf * 8, (4, 4), (1, 1), W_init=w_init,
b_init=None)(up7)
up7 = BatchNorm2d(decay=0.9,
act=lrelu,
gamma_init=gamma_init,
name=None)(up7)
c_size = c_size * 2
if c_size == out_size:
no = up7
break
up6 = Concat(concat_dim=3)([up7, conv6])
up6 = DeConv2d(ngf * 4, (4, 4), (2, 2), W_init=w_init,
b_init=None)(up6)
up6 = BatchNorm2d(decay=0.9,
act=lrelu,
gamma_init=gamma_init,
name=None)(up6)
up5 = Concat(concat_dim=3)([up6, conv5])
up5 = DeConv2d(ngf * 4, (4, 4), (1, 1), W_init=w_init,
b_init=None)(up5)
up5 = BatchNorm2d(decay=0.9,
act=lrelu,
gamma_init=gamma_init,
name=None)(up5)
c_size = c_size * 2
if c_size == out_size:
no = up5
break
up4 = Concat(concat_dim=3)([up5, conv4])
up4 = DeConv2d(ngf * 2, (4, 4), (2, 2), W_init=w_init,
b_init=None)(up4)
up4 = BatchNorm2d(decay=0.9,
act=lrelu,
gamma_init=gamma_init,
name=None)(up4)
up3 = Concat(concat_dim=3)([up4, conv3])
up3 = DeConv2d(ngf * 2, (4, 4), (1, 1), W_init=w_init,
b_init=None)(up3)
up3 = BatchNorm2d(decay=0.9,
act=lrelu,
gamma_init=gamma_init,
name=None)(up3)
c_size = c_size * 2
if c_size == out_size:
no = up3
break
up2 = Concat(concat_dim=3)([up3, conv2])
up2 = DeConv2d(ngf * 1, (4, 4), (2, 2), W_init=w_init,
b_init=None)(up2)
up2 = BatchNorm2d(decay=0.9,
act=lrelu,
gamma_init=gamma_init,
name=None)(up2)
up1 = Concat(concat_dim=3)([up2, conv1])
up1 = DeConv2d(ngf * 1, (4, 4), (1, 1), W_init=w_init,
b_init=None)(up1)
up1 = BatchNorm2d(decay=0.9,
act=lrelu,
gamma_init=gamma_init,
name=None)(up1)
c_size = c_size * 2
if c_size == out_size:
no = up1
break
if is_tanh:
up0 = DeConv2d(out_channel, (3, 3), (1, 1),
W_init=w_init,
act=tf.nn.tanh)(no)
else:
up0 = DeConv2d(out_channel, (3, 3), (1, 1),
W_init=w_init,
b_init=None,
act=None)(no)
return up0
def cspdarknet53(input_data=None):
input_data = convolutional(input_data, (3, 3, 3, 32), activate_type='mish')
input_data = convolutional(input_data, (3, 3, 32, 64),
downsample=True,
activate_type='mish')
route = input_data
route = convolutional(route, (1, 1, 64, 64),
activate_type='mish',
name='conv_rote_block_1')
input_data = convolutional(input_data, (1, 1, 64, 64),
activate_type='mish')
for i in range(1):
input_data = residual_block(input_data,
64,
32,
64,
activate_type="mish")
input_data = convolutional(input_data, (1, 1, 64, 64),
activate_type='mish')
input_data = Concat()([input_data, route])
input_data = convolutional(input_data, (1, 1, 128, 64),
activate_type='mish')
input_data = convolutional(input_data, (3, 3, 64, 128),
downsample=True,
activate_type='mish')
route = input_data
route = convolutional(route, (1, 1, 128, 64),
activate_type='mish',
name='conv_rote_block_2')
input_data = convolutional(input_data, (1, 1, 128, 64),
activate_type='mish')
for i in range(2):
input_data = residual_block(input_data,
64,
64,
64,
activate_type="mish")
input_data = convolutional(input_data, (1, 1, 64, 64),
activate_type='mish')
input_data = Concat()([input_data, route])
input_data = convolutional(input_data, (1, 1, 128, 128),
activate_type='mish')
input_data = convolutional(input_data, (3, 3, 128, 256),
downsample=True,
activate_type='mish')
route = input_data
route = convolutional(route, (1, 1, 256, 128),
activate_type='mish',
name='conv_rote_block_3')
input_data = convolutional(input_data, (1, 1, 256, 128),
activate_type='mish')
for i in range(8):
input_data = residual_block(input_data,
128,
128,
128,
activate_type="mish")
input_data = convolutional(input_data, (1, 1, 128, 128),
activate_type='mish')
input_data = Concat()([input_data, route])
input_data = convolutional(input_data, (1, 1, 256, 256),
activate_type='mish')
route_1 = input_data
input_data = convolutional(input_data, (3, 3, 256, 512),
downsample=True,
activate_type='mish')
route = input_data
route = convolutional(route, (1, 1, 512, 256),
activate_type='mish',
name='conv_rote_block_4')
input_data = convolutional(input_data, (1, 1, 512, 256),
activate_type='mish')
for i in range(8):
input_data = residual_block(input_data,
256,
256,
256,
activate_type="mish")
input_data = convolutional(input_data, (1, 1, 256, 256),
activate_type='mish')
input_data = Concat()([input_data, route])
input_data = convolutional(input_data, (1, 1, 512, 512),
activate_type='mish')
route_2 = input_data
input_data = convolutional(input_data, (3, 3, 512, 1024),
downsample=True,
activate_type='mish')
route = input_data
route = convolutional(route, (1, 1, 1024, 512),
activate_type='mish',
name='conv_rote_block_5')
input_data = convolutional(input_data, (1, 1, 1024, 512),
activate_type='mish')
for i in range(4):
input_data = residual_block(input_data,
512,
512,
512,
activate_type="mish")
input_data = convolutional(input_data, (1, 1, 512, 512),
activate_type='mish')
input_data = Concat()([input_data, route])
input_data = convolutional(input_data, (1, 1, 1024, 1024),
activate_type='mish')
input_data = convolutional(input_data, (1, 1, 1024, 512))
input_data = convolutional(input_data, (3, 3, 512, 1024))
input_data = convolutional(input_data, (1, 1, 1024, 512))
maxpool1 = MaxPool2d(filter_size=(13, 13), strides=(1, 1))(input_data)
maxpool2 = MaxPool2d(filter_size=(9, 9), strides=(1, 1))(input_data)
maxpool3 = MaxPool2d(filter_size=(5, 5), strides=(1, 1))(input_data)
input_data = Concat()([maxpool1, maxpool2, maxpool3, input_data])
input_data = convolutional(input_data, (1, 1, 2048, 512))
input_data = convolutional(input_data, (3, 3, 512, 1024))
input_data = convolutional(input_data, (1, 1, 1024, 512))
return route_1, route_2, input_data
def YOLOv4(NUM_CLASS, pretrained=False):
input_layer = Input([None, INPUT_SIZE, INPUT_SIZE, 3])
route_1, route_2, conv = cspdarknet53(input_layer)
route = conv
conv = convolutional(conv, (1, 1, 512, 256))
conv = upsample(conv)
route_2 = convolutional(route_2, (1, 1, 512, 256), name='conv_yolo_1')
conv = Concat()([route_2, conv])
conv = convolutional(conv, (1, 1, 512, 256))
conv = convolutional(conv, (3, 3, 256, 512))
conv = convolutional(conv, (1, 1, 512, 256))
conv = convolutional(conv, (3, 3, 256, 512))
conv = convolutional(conv, (1, 1, 512, 256))
route_2 = conv
conv = convolutional(conv, (1, 1, 256, 128))
conv = upsample(conv)
route_1 = convolutional(route_1, (1, 1, 256, 128), name='conv_yolo_2')
conv = Concat()([route_1, conv])
conv = convolutional(conv, (1, 1, 256, 128))
conv = convolutional(conv, (3, 3, 128, 256))
conv = convolutional(conv, (1, 1, 256, 128))
conv = convolutional(conv, (3, 3, 128, 256))
conv = convolutional(conv, (1, 1, 256, 128))
route_1 = conv
conv = convolutional(conv, (3, 3, 128, 256), name='conv_route_1')
conv_sbbox = convolutional(conv, (1, 1, 256, 3 * (NUM_CLASS + 5)),
activate=False,
bn=False)
conv = convolutional(route_1, (3, 3, 128, 256),
downsample=True,
name='conv_route_2')
conv = Concat()([conv, route_2])
conv = convolutional(conv, (1, 1, 512, 256))
conv = convolutional(conv, (3, 3, 256, 512))
conv = convolutional(conv, (1, 1, 512, 256))
conv = convolutional(conv, (3, 3, 256, 512))
conv = convolutional(conv, (1, 1, 512, 256))
route_2 = conv
conv = convolutional(conv, (3, 3, 256, 512), name='conv_route_3')
conv_mbbox = convolutional(conv, (1, 1, 512, 3 * (NUM_CLASS + 5)),
activate=False,
bn=False)
conv = convolutional(route_2, (3, 3, 256, 512),
downsample=True,
name='conv_route_4')
conv = Concat()([conv, route])
conv = convolutional(conv, (1, 1, 1024, 512))
conv = convolutional(conv, (3, 3, 512, 1024))
conv = convolutional(conv, (1, 1, 1024, 512))
conv = convolutional(conv, (3, 3, 512, 1024))
conv = convolutional(conv, (1, 1, 1024, 512))
conv = convolutional(conv, (3, 3, 512, 1024))
conv_lbbox = convolutional(conv, (1, 1, 1024, 3 * (NUM_CLASS + 5)),
activate=False,
bn=False)
network = Model(input_layer, [conv_sbbox, conv_mbbox, conv_lbbox])
if pretrained:
restore_params(network, model_path='model/model.npz')
return network
def batch_normal_u_net(self):
# built encoder
inputs = Input(self.in_shape, name='inputs')
conv1 = Conv2d(64, (4, 4), (2, 2), name='conv1')(inputs)
conv2 = Conv2d(128, (4, 4), (2, 2), name='conv2')(conv1)
conv2 = BatchNorm(act=tl.act.lrelu, is_train=self.train_bn,
name='bn2')(conv2)
conv3 = Conv2d(256, (4, 4), (2, 2), name='conv3')(conv2)
conv3 = BatchNorm(act=tl.act.lrelu, is_train=self.train_bn,
name='bn3')(conv3)
conv4 = Conv2d(512, (4, 4), (2, 2), name='conv4')(conv3)
conv4 = BatchNorm(act=tl.act.lrelu, is_train=self.train_bn,
name='bn4')(conv4)
conv5 = Conv2d(512, (4, 4), (2, 2), name='conv5')(conv4)
conv5 = BatchNorm(act=tl.act.lrelu, is_train=self.train_bn,
name='bn5')(conv5)
conv6 = Conv2d(512, (4, 4), (2, 2), name='conv6')(conv5)
conv6 = BatchNorm(act=tl.act.lrelu, is_train=self.train_bn,
name='bn6')(conv6)
conv7 = Conv2d(512, (4, 4), (2, 2), name='conv7')(conv6)
conv7 = BatchNorm(act=tl.act.lrelu, is_train=self.train_bn,
name='bn7')(conv7)
conv8 = Conv2d(512, (4, 4), (2, 2), act=tl.act.lrelu,
name='conv8')(conv7)
# built decoder
up7 = DeConv2d(512, (4, 4), name='deconv7')(conv8)
up7 = BatchNorm(act=tf.nn.relu, is_train=self.train_bn,
name='dbn7')(up7)
up6 = Concat(concat_dim=3, name='concat6')([up7, conv7])
up6 = DeConv2d(1024, (4, 4), name='deconv6')(up6)
up6 = BatchNorm(act=tf.nn.relu, is_train=self.train_bn,
name='dbn6')(up6)
up5 = Concat(concat_dim=3, name='concat5')([up6, conv6])
up5 = DeConv2d(1024, (4, 4), name='deconv5')(up5)
up5 = BatchNorm(act=tf.nn.relu, is_train=self.train_bn,
name='dbn5')(up5)
up4 = Concat(concat_dim=3, name='concat4')([up5, conv5])
up4 = DeConv2d(1024, (4, 4), name='deconv4')(up4)
up4 = BatchNorm(act=tf.nn.relu, is_train=self.train_bn,
name='dbn4')(up4)
up3 = Concat(concat_dim=3, name='concat3')([up4, conv4])
up3 = DeConv2d(256, (4, 4), name='deconv3')(up3)
up3 = BatchNorm(act=tf.nn.relu, is_train=self.train_bn,
name='dbn3')(up3)
up2 = Concat(concat_dim=3, name='concat2')([up3, conv3])
up2 = DeConv2d(128, (4, 4), name='deconv2')(up2)
up2 = BatchNorm(act=tf.nn.relu, is_train=self.train_bn,
name='dbn2')(up2)
up1 = Concat(concat_dim=3, name='concat1')([up2, conv2])
up1 = DeConv2d(64, (4, 4), name='deconv1')(up1)
up1 = BatchNorm(act=tf.nn.relu, is_train=self.train_bn,
name='dbn1')(up1)
up0 = Concat(concat_dim=3, name='concat0')([up1, conv1])
up0 = DeConv2d(64, (4, 4), name='deconv0')(up0)
up0 = BatchNorm(act=tf.nn.relu, is_train=self.train_bn,
name='dbn0')(up0)
outs = Conv2d(3, (1, 1), act=tf.nn.sigmoid, name='out')(up0)
return Model(inputs=inputs, outputs=outs, name="BN_U_Net")
def YOLOv4(NUM_CLASS, pretrained=False):
"""Pre-trained YOLOv4 model.
Parameters
------------
NUM_CLASS : int
Number of classes in final prediction.
pretrained : boolean
Whether to load pretrained weights. Default False.
Examples
---------
Object Detection with YOLOv4, see `computer_vision.py
<https://github.com/tensorlayer/tensorlayer/blob/master/tensorlayer/app/computer_vision.py>`__
With TensorLayer
>>> # get the whole model, without pre-trained YOLOv4 parameters
>>> yolov4 = tl.app.YOLOv4(NUM_CLASS=80, pretrained=False)
>>> # get the whole model, restore pre-trained YOLOv4 parameters
>>> yolov4 = tl.app.YOLOv4(NUM_CLASS=80, pretrained=True)
>>> # use for inferencing
>>> output = yolov4(img, is_train=False)
"""
input_layer = Input([None, INPUT_SIZE, INPUT_SIZE, 3])
route_1, route_2, conv = cspdarknet53(input_layer)
route = conv
conv = convolutional(conv, (1, 1, 512, 256))
conv = upsample(conv)
route_2 = convolutional(route_2, (1, 1, 512, 256), name='conv_yolo_1')
conv = Concat()([route_2, conv])
conv = convolutional(conv, (1, 1, 512, 256))
conv = convolutional(conv, (3, 3, 256, 512))
conv = convolutional(conv, (1, 1, 512, 256))
conv = convolutional(conv, (3, 3, 256, 512))
conv = convolutional(conv, (1, 1, 512, 256))
route_2 = conv
conv = convolutional(conv, (1, 1, 256, 128))
conv = upsample(conv)
route_1 = convolutional(route_1, (1, 1, 256, 128), name='conv_yolo_2')
conv = Concat()([route_1, conv])
conv = convolutional(conv, (1, 1, 256, 128))
conv = convolutional(conv, (3, 3, 128, 256))
conv = convolutional(conv, (1, 1, 256, 128))
conv = convolutional(conv, (3, 3, 128, 256))
conv = convolutional(conv, (1, 1, 256, 128))
route_1 = conv
conv = convolutional(conv, (3, 3, 128, 256), name='conv_route_1')
conv_sbbox = convolutional(conv, (1, 1, 256, 3 * (NUM_CLASS + 5)), activate=False, bn=False)
conv = convolutional(route_1, (3, 3, 128, 256), downsample=True, name='conv_route_2')
conv = Concat()([conv, route_2])
conv = convolutional(conv, (1, 1, 512, 256))
conv = convolutional(conv, (3, 3, 256, 512))
conv = convolutional(conv, (1, 1, 512, 256))
conv = convolutional(conv, (3, 3, 256, 512))
conv = convolutional(conv, (1, 1, 512, 256))
route_2 = conv
conv = convolutional(conv, (3, 3, 256, 512), name='conv_route_3')
conv_mbbox = convolutional(conv, (1, 1, 512, 3 * (NUM_CLASS + 5)), activate=False, bn=False)
conv = convolutional(route_2, (3, 3, 256, 512), downsample=True, name='conv_route_4')
conv = Concat()([conv, route])
conv = convolutional(conv, (1, 1, 1024, 512))
conv = convolutional(conv, (3, 3, 512, 1024))
conv = convolutional(conv, (1, 1, 1024, 512))
conv = convolutional(conv, (3, 3, 512, 1024))
conv = convolutional(conv, (1, 1, 1024, 512))
conv = convolutional(conv, (3, 3, 512, 1024))
conv_lbbox = convolutional(conv, (1, 1, 1024, 3 * (NUM_CLASS + 5)), activate=False, bn=False)
network = Model(input_layer, [conv_sbbox, conv_mbbox, conv_lbbox])
if pretrained:
restore_params(network, model_path='model/yolov4_model.npz')
return network
def u_net(inputs, refine=False):
w_init = tf.random_normal_initializer(stddev=0.02)
g_init = tf.random_normal_initializer(1., 0.02)
lrelu = lambda x: tl.act.lrelu(x, 0.2)
# ENCODER
conv1 = Conv2d(64, (4, 4), (2, 2), padding='SAME', W_init=w_init)(inputs)
conv1 = InstanceNorm2d(act=lrelu, gamma_init=g_init)(conv1)
conv2 = Conv2d(128, (4, 4), (2, 2), padding='SAME', W_init=w_init)(conv1)
conv2 = InstanceNorm2d(act=lrelu, gamma_init=g_init)(conv2)
conv3 = Conv2d(256, (4, 4), (2, 2), padding='SAME', W_init=w_init)(conv2)
conv3 = InstanceNorm2d(act=lrelu, gamma_init=g_init)(conv3)
conv4 = Conv2d(512, (4, 4), (2, 2), padding='SAME', W_init=w_init)(conv3)
conv4 = InstanceNorm2d(act=lrelu, gamma_init=g_init)(conv4)
conv5 = Conv2d(512, (4, 4), (2, 2), padding='SAME', W_init=w_init)(conv4)
conv5 = InstanceNorm2d(act=lrelu, gamma_init=g_init)(conv5)
conv6 = Conv2d(512, (4, 4), (2, 2), padding='SAME', W_init=w_init)(conv5)
conv6 = InstanceNorm2d(act=lrelu, gamma_init=g_init)(conv6)
conv7 = Conv2d(512, (4, 4), (2, 2), padding='SAME', W_init=w_init)(conv6)
conv7 = InstanceNorm2d(act=lrelu, gamma_init=g_init)(conv7)
conv8 = Conv2d(512, (4, 4), (2, 2), padding='SAME', W_init=w_init)(conv7)
conv8 = InstanceNorm2d(act=lrelu, gamma_init=g_init)(conv8)
# DECODER
d0 = DeConv2d(n_filter=512, filter_size=(4, 4))(conv8)
d0 = Dropout(0.5)(d0)
d0 = Concat()(
[InstanceNorm2d(act=tf.nn.relu, gamma_init=g_init)(d0), conv7])
d1 = DeConv2d(n_filter=512, filter_size=(4, 4))(d0)
d1 = Dropout(0.5)(d1)
d1 = Concat()(
[InstanceNorm2d(act=tf.nn.relu, gamma_init=g_init)(d1), conv6])
d2 = DeConv2d(n_filter=512, filter_size=(4, 4))(d1)
d2 = Dropout(0.5)(d2)
d2 = Concat()(
[InstanceNorm2d(act=tf.nn.relu, gamma_init=g_init)(d2), conv5])
d3 = DeConv2d(n_filter=512, filter_size=(4, 4))(d2)
d3 = Concat()(
[InstanceNorm2d(act=tf.nn.relu, gamma_init=g_init)(d3), conv4])
d4 = DeConv2d(n_filter=256, filter_size=(4, 4))(d3)
d4 = Concat()(
[InstanceNorm2d(act=tf.nn.relu, gamma_init=g_init)(d4), conv3])
d5 = DeConv2d(n_filter=128, filter_size=(4, 4))(d4)
d5 = Concat()(
[InstanceNorm2d(act=tf.nn.relu, gamma_init=g_init)(d5), conv2])
d6 = DeConv2d(n_filter=64, filter_size=(4, 4))(d5)
d6 = Concat()(
[InstanceNorm2d(act=tf.nn.relu, gamma_init=g_init)(d6), conv1])
d7 = DeConv2d(n_filter=64, filter_size=(4, 4))(d6)
d7 = InstanceNorm2d(act=tf.nn.relu, gamma_init=g_init)(d7)
nn = Conv2d(1, (1, 1), (1, 1),
act=tf.nn.tanh,
padding='SAME',
W_init=w_init)(d7)
if refine:
nn = RampElementwise(tf.add, act=tl.act.ramp, v_min=-1)([nn, inputs])
return nn
def get_D_Conditional(input_shape):
w_init = tf.random_normal_initializer(stddev=0.02)
b_init = None
gamma_init = tf.random_normal_initializer(1., 0.02)
lrelu = lambda x: tl.act.lrelu(x, 0.2)
#with tf.variable_scope("SRGAN_d", reuse=reuse) as vs:
# tl.layers.set_name_reuse(reuse) # remove for TL 1.8.0+
nin_lr = Input((input_shape[0], input_shape[1] / 8, input_shape[2] / 8,
input_shape[3]))
nin_hr = Input(input_shape)
n_hr = Conv2d(64, (3, 3), (2, 2), act=lrelu, padding='SAME',
W_init=w_init)(nin_hr)
n_hr = BatchNorm2d(gamma_init=gamma_init)(n_hr)
n_hr = Conv2d(64, (3, 3), (2, 2), act=lrelu, padding='SAME',
W_init=w_init)(n_hr)
n_hr = BatchNorm2d(gamma_init=gamma_init)(n_hr)
n_hr = Conv2d(64, (3, 3), (2, 2), act=lrelu, padding='SAME',
W_init=w_init)(n_hr)
n_hr = BatchNorm2d(gamma_init=gamma_init)(n_hr)
n_lr = Conv2d(64, (3, 3), (1, 1), act=lrelu, padding='SAME',
W_init=w_init)(nin_lr)
n_lr = BatchNorm2d(gamma_init=gamma_init)(n_lr)
n_lr = Conv2d(64, (3, 3), (1, 1), act=lrelu, padding='SAME',
W_init=w_init)(n_lr)
n_lr = BatchNorm2d(gamma_init=gamma_init)(n_lr)
n_lr = Conv2d(64, (3, 3), (1, 1), act=lrelu, padding='SAME',
W_init=w_init)(n_lr)
n_lr = BatchNorm2d(gamma_init=gamma_init)(n_lr)
n = Concat(concat_dim=-1)([n_lr, n_hr])
n = Conv2d(128, (3, 3), (1, 1),
act=lrelu,
padding='SAME',
W_init=w_init,
b_init=b_init,
name='n128s1/c')(n)
n = BatchNorm2d(gamma_init=gamma_init)(n)
n = Conv2d(128, (3, 3), (2, 2),
act=lrelu,
padding='SAME',
W_init=w_init,
b_init=b_init,
name='n128s2/c')(n)
n = BatchNorm2d(gamma_init=gamma_init)(n)
n = Conv2d(256, (3, 3), (1, 1),
act=lrelu,
padding='SAME',
W_init=w_init,
b_init=b_init,
name='n256s1/c')(n)
n = BatchNorm2d(gamma_init=gamma_init)(n)
n = Conv2d(256, (3, 3), (2, 2),
act=lrelu,
padding='SAME',
W_init=w_init,
b_init=b_init,
name='n256s2/c')(n)
n = BatchNorm2d(gamma_init=gamma_init)(n)
n = Conv2d(512, (3, 3), (1, 1),
act=lrelu,
padding='SAME',
W_init=w_init,
b_init=b_init,
name='n512s1/c')(n)
n = BatchNorm2d(gamma_init=gamma_init)(n)
n = Conv2d(512, (3, 3), (2, 2),
act=lrelu,
padding='SAME',
W_init=w_init,
b_init=b_init,
name='n512s2/c')(n)
n = BatchNorm2d(gamma_init=gamma_init)(n)
n = Flatten()(n)
n = Dense(n_units=1024, act=lrelu, name='d1024', W_init=w_init)(n)
no = Dense(n_units=1, act=None, name='out', W_init=w_init)(n)
D = Model(inputs=[nin_lr, nin_hr], outputs=no)
return D