def densely_connected_residual_block(inputs):
_, _, _, c = inputs.get_shape().as_list()
growth_rate = int(c / 2)
x1 = layers.Conv2D(
filters=growth_rate,
kernel_size=(3, 3),
strides=(1, 1),
padding='same',
)(inputs)
x1 = layers.PReLU()(x1)
x2_inputs = layers.Concatenate()([x1, inputs])
x2 = layers.Conv2D(
filters=growth_rate,
kernel_size=(3, 3),
strides=(1, 1),
padding='same',
)(x2_inputs)
x2 = layers.PReLU()(x2)
x3_inputs = layers.Concatenate()([x1, x2, inputs])
x3 = layers.Conv2D(
filters=c,
kernel_size=(3, 3),
strides=(1, 1),
padding='same',
)(x3_inputs)
x3 = layers.PReLU()(x3)
return x3
def fully_connected_net(args):
window_len = args[0]
input_state_shape = (10, )
pre_int_shape = (window_len, 3)
imu_input_shape = (window_len, 7, 1)
# Input layers. Don't change names
imu_in = layers.Input(imu_input_shape, name="imu_input")
state_in = layers.Input(input_state_shape, name="state_input")
_, _, dt_vec = custom_layers.PreProcessIMU()(imu_in)
x = layers.Flatten()(imu_in)
x = layers.Dense(200)(x)
x = norm_activate(x, 'relu')
x = layers.Dense(400)(x)
x = norm_activate(x, 'relu')
x = layers.Dense(400)(x)
feat_vec = norm_activate(x, 'relu')
r_flat = layers.Dense(tf.reduce_prod(pre_int_shape))(x)
rot_prior = layers.Reshape(pre_int_shape, name="pre_integrated_R")(r_flat)
x = layers.Concatenate()([feat_vec, r_flat])
v_flat = layers.Dense(tf.reduce_prod(pre_int_shape))(x)
v_prior = layers.Reshape(pre_int_shape, name="pre_integrated_v")(v_flat)
x = layers.Concatenate()([feat_vec, r_flat, v_flat])
p_flat = layers.Dense(tf.reduce_prod(pre_int_shape))(x)
p_prior = layers.Reshape(pre_int_shape, name="pre_integrated_p")(p_flat)
return Model(inputs=(imu_in, state_in),
outputs=(rot_prior, v_prior, p_prior))
def cnn_rnn_pre_int_net(window_len, n_iterations):
input_state_shape = (10, )
pre_int_shape = (window_len, 3)
imu_input_shape = (window_len, 7, 1)
b_norm = False
# Input layers. Don't change names
imu_in = layers.Input(imu_input_shape, name="imu_input")
state_in = layers.Input(input_state_shape, name="state_input")
gyro, acc, dt_vec = custom_layers.PreProcessIMU()(imu_in)
# Convolution features
channels = [2**i for i in range(2, 2 + n_iterations + 1)]
final_shape = (pre_int_shape[0], pre_int_shape[1], channels[-1])
gyro_feat_vec = down_scaling_loop(gyro, n_iterations, 0, channels,
window_len, final_shape, n_iterations,
b_norm)
acc_feat_vec = down_scaling_loop(acc, n_iterations, 0, channels,
window_len, final_shape, n_iterations,
b_norm)
# Pre-integrated rotation
x = layers.GRU(64, return_sequences=True)(gyro_feat_vec)
x = layers.TimeDistributed(layers.Dense(50, activation='tanh'))(x)
rot_prior = layers.TimeDistributed(layers.Dense(pre_int_shape[1]),
name="pre_integrated_R")(x)
# Pre-integrated velocity
x = custom_layers.PreIntegrationForwardDense(pre_int_shape)(rot_prior)
rot_contrib = norm_activate(x, 'leakyRelu', b_norm)
v_feat_vec = layers.Concatenate()(
[gyro_feat_vec, acc_feat_vec, rot_contrib])
x = layers.GRU(64, return_sequences=True)(v_feat_vec)
x = layers.TimeDistributed(layers.Dense(50, activation='tanh'))(x)
v_prior = layers.TimeDistributed(layers.Dense(pre_int_shape[1]),
name="pre_integrated_v")(x)
# Pre-integrated position
x = custom_layers.PreIntegrationForwardDense(pre_int_shape)(rot_prior)
rot_contrib = norm_activate(x, 'leakyRelu', b_norm)
x = custom_layers.PreIntegrationForwardDense(pre_int_shape)(v_prior)
vel_contrib = norm_activate(x, 'leakyRelu', b_norm)
pos_in = layers.Concatenate()(
[gyro_feat_vec, acc_feat_vec, rot_contrib, vel_contrib])
x = layers.GRU(64, return_sequences=True)(pos_in)
x = layers.TimeDistributed(layers.Dense(50, activation='tanh'))(x)
p_prior = layers.TimeDistributed(layers.Dense(pre_int_shape[1]),
name="pre_integrated_p")(x)
rot_prior_, v_prior_, p_prior_ = custom_layers.DifferenceRegularizer(
0.005)((rot_prior, v_prior, p_prior))
state_out = custom_layers.IntegratingLayer(name="state_output")(
[state_in, rot_prior_, v_prior_, p_prior_, dt_vec])
return Model(inputs=(imu_in, state_in), outputs=(rot_prior, v_prior, p_prior)), \
Model(inputs=(imu_in, state_in), outputs=(rot_prior, v_prior, p_prior, state_out))
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 inception_model(input_tensor, filters_1_1, filters_3_3_reduce, filters_3_3,
filters_5_5_reduce, filters_5_5, filters_pool_proj):
conv_1_1 = layers.Conv2D(filters_1_1, (1, 1), padding='same')(input_tensor)
conv_1_1 = layers.Activation('relu')(conv_1_1)
conv_3_3_reduce = layers.Conv2D(filters_3_3_reduce, (1, 1),
padding='same')(input_tensor)
conv_3_3_reduce = layers.Activation('relu')(conv_3_3_reduce)
conv_3_3 = layers.Conv2D(filters_3_3, (3, 3),
padding='same')(conv_3_3_reduce)
conv_3_3 = layers.Activation('relu')(conv_3_3)
conv_5_5_reduce = layers.Conv2D(filters_5_5_reduce, (1, 1),
padding='same')(input_tensor)
conv_5_5_reduce = layers.Activation('relu')(conv_5_5_reduce)
conv_5_5 = layers.Conv2D(filters_5_5, (5, 5),
padding='same')(conv_5_5_reduce)
conv_5_5 = layers.Activation('relu')(conv_5_5)
maxpooling = layers.MaxPooling2D(pool_size=(3, 3),
strides=(1, 1),
padding='same')(input_tensor)
maxpooling_proj = layers.Conv2D(filters_pool_proj, (1, 1),
padding='same')(maxpooling)
inception_output = layers.Concatenate()(
[conv_1_1, conv_3_3, conv_5_5, maxpooling_proj])
return inception_output
def create_img2attr(self, kernel_initializer = 'he_normal', img_flat_len = 1024):
attr_input = layers.Input(shape = (50,), name = 'attr')
word_emb = layers.Input(shape = (600,), name = 'wv')
imag_classifier = layers.Input(shape = (img_flat_len,), name = 'img')
attr_dense = layers.Dense(600, use_bias = True, kernel_initializer=kernel_initializer,
kernel_regularizer = l2(1e-4), name = 'attr_dense')(attr_input)
attr_word_emb = layers.Concatenate(name = 'attr_word_emb')([word_emb, attr_dense])
out_size = 50
attr_preds = self.full_connect_layer(imag_classifier, hidden_dim = [
int(out_size * 20),
int(out_size * 15),
# int(out_size * 7),
# int(img_flat_len * 1.125),
# int(img_flat_len * 1.0625)
], \
activation = 'relu', resnet = False, drop_out_ratio = 0.2)
attr_preds = self.full_connect_layer(attr_preds, hidden_dim = [out_size], activation = 'sigmoid')
log_loss = K.mean(binary_crossentropy(attr_input, attr_preds))
model = Model([attr_input, word_emb, imag_classifier], outputs = [attr_preds]) #, vgg_output])
model.add_loss(log_loss)
model.compile(optimizer=Adam(lr=1e-5), loss=None)
return model
def create_dem_aug(self, kernel_initializer = 'he_normal', img_flat_len = 1024):
attr_input = layers.Input(shape = (50,), name = 'attr')
word_emb = layers.Input(shape = (600,), name = 'wv')
img_input = layers.Input(shape = (64, 64, 3))
# imag_classifier = layers.Input(shape = (img_flat_len,), name = 'img')
self.img_flat_model.trainable = False
imag_classifier = self.img_flat_model(img_input)
attr_dense = layers.Dense(600, use_bias = True, kernel_initializer=kernel_initializer,
kernel_regularizer = l2(1e-4), name = 'attr_dense')(attr_input)
if self.only_emb:
attr_word_emb = word_emb
else:
attr_word_emb = layers.Concatenate(name = 'attr_word_emb')([word_emb, attr_dense])
attr_word_emb_dense = self.full_connect_layer(attr_word_emb, hidden_dim = [
int(img_flat_len * 2),
int(img_flat_len * 1.5),
int(img_flat_len * 1.25),
# int(img_flat_len * 1.125),
# int(img_flat_len * 1.0625)
], \
activation = 'relu', resnet = False, drop_out_ratio = 0.2)
attr_word_emb_dense = self.full_connect_layer(attr_word_emb_dense, hidden_dim = [img_flat_len],
activation = 'relu')
mse_loss = K.mean(mean_squared_error(imag_classifier, attr_word_emb_dense))
model = Model([img_input, attr_input, word_emb], outputs = [attr_word_emb_dense, imag_classifier]) #, vgg_output])
model.add_loss(mse_loss)
model.compile(optimizer=Adam(lr=1e-4), loss=None)
return model
def conv_block(x, growth_rate, name):
"""A building block for a dense block.
Arguments:
x: input tensor.
growth_rate: float, growth rate at dense layers.
name: string, block label.
Returns:
Output tensor for the block.
"""
bn_axis = 3 if backend.image_data_format() == 'channels_last' else 1
x1 = layers.BatchNormalization(axis=bn_axis,
epsilon=1.001e-5,
name=name + '_0_bn')(x)
x1 = layers.Activation('relu', name=name + '_0_relu')(x1)
x1 = layers.Conv2D(4 * growth_rate,
1,
use_bias=False,
name=name + '_1_conv')(x1)
x1 = layers.BatchNormalization(axis=bn_axis,
epsilon=1.001e-5,
name=name + '_1_bn')(x1)
x1 = layers.Activation('relu', name=name + '_1_relu')(x1)
x1 = layers.Conv2D(growth_rate,
3,
padding='same',
use_bias=False,
name=name + '_2_conv')(x1)
x = layers.Concatenate(axis=bn_axis, name=name + '_concat')([x, x1])
return x
def __init__(self, atrous_rates, norm_layer, norm_kwargs, conv_trainable=True, **kwargs):
super(ASPP, self).__init__()
out_channels = 256
self.b0 = tf.keras.Sequential([
klayers.Conv2D(out_channels, kernel_size=1, kernel_initializer='he_uniform', use_bias=False,
trainable=conv_trainable),
norm_layer(**({} if norm_kwargs is None else norm_kwargs)),
klayers.ReLU()
])
rate1, rate2, rate3 = tuple(atrous_rates)
self.b1 = ASPPConv(out_channels, rate1, norm_layer, norm_kwargs, conv_trainable=conv_trainable)
self.b2 = ASPPConv(out_channels, rate2, norm_layer, norm_kwargs, conv_trainable=conv_trainable)
self.b3 = ASPPConv(out_channels, rate3, norm_layer, norm_kwargs, conv_trainable=conv_trainable)
self.b4 = ASPPPooling(out_channels, norm_layer=norm_layer, norm_kwargs=norm_kwargs,
conv_trainable=conv_trainable)
self.concat = klayers.Concatenate()
self.project = tf.keras.Sequential([
klayers.Conv2D(out_channels, kernel_size=1, kernel_initializer='he_uniform', use_bias=False,
trainable=conv_trainable),
norm_layer(**({} if norm_kwargs is None else norm_kwargs)),
klayers.ReLU(),
klayers.Dropout(0.5)
])
def spp(x):
x_1 = x
x_2 = layers.MaxPooling2D(pool_size=5, strides=1, padding='same')(x)
x_3 = layers.MaxPooling2D(pool_size=9, strides=1, padding='same')(x)
x_4 = layers.MaxPooling2D(pool_size=13, strides=1, padding='same')(x)
out = layers.Concatenate()([x_4, x_3, x_2, x_1])
return out
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 conv_block(x, growth_rate, name):
"""A building block for a dense block.
# Arguments
x: input tensor.
growth_rate: float, growth rate at dense layers.
name: string, block label.
# Returns
Output tensor for the block.
"""
bn_axis = 3
x1 = layers.BatchNormalization(axis=bn_axis,
epsilon=1.001e-5,
name=name + '_0_bn')(x)
x1 = layers.Activation('relu', name=name + '_0_relu')(x1)
x1 = layers.Conv2D(4 * growth_rate,
1,
use_bias=False,
kernel_regularizer=regularizers.l2(l2_reg),
name=name + '_1_conv')(x1)
x1 = layers.BatchNormalization(axis=bn_axis,
epsilon=1.001e-5,
name=name + '_1_bn')(x1)
x1 = layers.Activation('relu', name=name + '_1_relu')(x1)
x1 = layers.Conv2D(growth_rate,
3,
padding='same',
use_bias=False,
kernel_regularizer=regularizers.l2(l2_reg),
name=name + '_2_conv')(x1)
x = layers.Concatenate(axis=bn_axis, name=name + '_concat')([x, x1])
return x
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 layer(input_tensor):
inp_ch = int(backend.int_shape(input_tensor)[-1] //
groups) # input grouped channels
out_ch = int(filters // groups) # output grouped channels
blocks = []
for c in range(groups):
slice_arguments = {
'start': c * inp_ch,
'stop': (c + 1) * inp_ch,
'axis': slice_axis,
}
x = layers.Lambda(slice_tensor,
arguments=slice_arguments)(input_tensor)
x = layers.Conv2D(out_ch,
kernel_size,
strides=strides,
kernel_initializer=kernel_initializer,
use_bias=use_bias,
activation=activation,
padding=padding)(x)
blocks.append(x)
x = layers.Concatenate(axis=slice_axis)(blocks)
return x
def cnn(x_ph, a_ph):
net = layers.Conv2D(32, (8, 8), strides=4, activation="relu")(x_ph)
net = layers.Conv2D(64, (4, 4), strides=2, activation="relu")(net)
net = layers.Conv2D(64, (3, 3), strides=1, activation="relu")(net)
net = layers.Flatten()(net)
with tf.variable_scope('pi'):
mu, pi, logp_pi = cnn_gaussian_policy(net, a_ph.shape.as_list()[-1])
mu, pi, logp_pi = apply_squashing_func(mu, pi, logp_pi)
with tf.variable_scope('q1'):
x_1 = layers.Dense(100, activation="relu")(net)
x_2 = layers.Dense(100, activation="relu")(a_ph)
q = layers.Concatenate()([x_1, x_2])
q = layers.Dense(100)(q)
q1 = layers.Dense(1)(q)
with tf.variable_scope('q1', reuse=True):
x_1 = layers.Dense(100, activation="relu")(net)
# a_input = layers.Input(shape=(act_dim,))
x_2 = layers.Dense(100, activation="relu")(pi)
q = layers.Concatenate()([x_1, x_2])
q = layers.Dense(100)(q)
q1_pi = layers.Dense(1)(q)
with tf.variable_scope('q2'):
x_1 = layers.Dense(100, activation="relu")(net)
x_2 = layers.Dense(100, activation="relu")(a_ph)
q = layers.Concatenate()([x_1, x_2])
q = layers.Dense(100)(q)
q2 = layers.Dense(1)(q)
with tf.variable_scope('q2', reuse=True):
x_1 = layers.Dense(100, activation="relu")(net)
# a_input = layers.Input(shape=(act_dim,))
x_2 = layers.Dense(100, activation="relu")(pi)
q = layers.Concatenate()([x_1, x_2])
q = layers.Dense(100)(q)
q2_pi = layers.Dense(1)(q)
with tf.variable_scope('v'):
q = layers.Dense(100, activation="relu")(net)
q = layers.Dense(100, activation="relu")(q)
v = layers.Dense(1)(q)
return mu, pi, logp_pi, q1, q2, q1_pi, q2_pi, v
def dense_block(x, blocks, filters, dropout_rate, name):
for i in range(blocks):
x1 = bottleneck_layer(x,
filters=filters,
dropout_rate=dropout_rate,
name=name + '_bottleN_' + str(i))
x = layers.Concatenate(axis=3)([x, x1])
return x
def make_parallel(keras_model, gpu_list):
"""Creates a new wrapper model that consists of multiple replicas of
the original model placed on different GPUs.
Args:
keras_model: the input model to replicate on multiple gpus
gpu_list: the number of replicas to build
Returns:
Multi-gpu model
"""
# Slice inputs. Slice inputs on the CPU to avoid sending a copy
# of the full inputs to all GPUs. Saves on bandwidth and memory.
gpu_list = [int(i) for i in gpu_list]
input_slices = {name: tf.split(x, len(gpu_list))
for name, x in zip(keras_model.input_names,
keras_model.inputs)}
output_names = keras_model.output_names
outputs_all = []
for i in range(len(keras_model.outputs)):
outputs_all.append([])
# Run the model call() on each GPU to place the ops there
for i in gpu_list:
with tf.device('/gpu:%d' % i):
with tf.name_scope('tower_%d' % i):
# Run a slice of inputs through this replica
zipped_inputs = zip(keras_model.input_names,
keras_model.inputs)
inputs = [
KL.Lambda(lambda s: input_slices[name][gpu_list.index(i)],
output_shape=lambda s: (None,) + s[1:])(tensor)
for name, tensor in zipped_inputs]
# Create the model replica and get the outputs
outputs = keras_model(inputs)
if not isinstance(outputs, list):
outputs = [outputs]
# Save the outputs for merging back together later
for l, o in enumerate(outputs):
outputs_all[l].append(o)
# Merge outputs on CPU
with tf.device('/cpu:0'):
merged = []
for outputs, name in zip(outputs_all, output_names):
# Concatenate or average outputs?
# Outputs usually have a batch dimension and we concatenate
# across it. If they don't, then the output is likely a loss
# or a metric value that gets averaged across the batch.
# Keras expects losses and metrics to be scalars.
if K.int_shape(outputs[0]) == ():
# Average
m = KL.Lambda(lambda o: tf.add_n(
o) / len(outputs), name=name)(outputs)
else:
# Concatenate
m = KL.Concatenate(axis=0, name=name)(outputs)
merged.append(m)
return merged
def create_model(self):
input_text = Input(shape=self.max_sequence_length)
input_image = Input(shape=(self.img_height, self.img_width,
self.num_channels))
embedded_id = layers.Embedding(self.vocab_size,
self.embedding_size)(input_text)
embedded_id = layers.Flatten()(embedded_id)
embedded_id = layers.Dense(units=input_image.shape[1] *
input_image.shape[2])(embedded_id)
embedded_id = layers.Reshape(target_shape=(input_image.shape[1],
input_image.shape[2],
1))(embedded_id)
x = layers.Concatenate(axis=3)([input_image, embedded_id])
x = layers.Conv2D(filters=64,
kernel_size=(3, 3),
strides=(2, 2),
padding='same')(x)
x = layers.LeakyReLU()(x)
x = layers.Dropout(0.3)(x)
x = layers.Conv2D(filters=64,
kernel_size=(3, 3),
strides=(2, 2),
padding='same')(x)
x = layers.LeakyReLU()(x)
x = layers.Dropout(rate=0.3)(x)
# x = layers.Conv2D(filters=64, kernel_size=(3, 3), strides=(2, 2), padding='same')(x)
# x = layers.LeakyReLU()(x)
# x = layers.Dropout(rate=0.3)(x)
#
# x = layers.Conv2D(filters=128, kernel_size=(3, 3), strides=(2, 2), padding='same')(x)
# x = layers.LeakyReLU()(x)
# x = layers.Dropout(rate=0.3)(x)
x = layers.Conv2D(filters=128,
kernel_size=(3, 3),
strides=(2, 2),
padding='same')(x)
x = layers.LeakyReLU()(x)
x = layers.Dropout(rate=0.3)(x)
x = layers.Flatten()(x)
x = layers.Dense(units=1000)(x)
x = layers.LeakyReLU()(x)
x = layers.Dense(units=1)(x)
model = Model(name='discriminator',
inputs=[input_text, input_image],
outputs=x)
return model
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 get_double_concat_test_model(input_shapes):
inputs = []
for i, input_shape in enumerate(input_shapes):
inputs.append(
tf.keras.Input(shape=input_shape[1:],
name='input_{}'.format(i + 1)))
# pylint: disable=unbalanced-tuple-unpacking
input_1, input_2 = inputs
x_1 = input_1 * input_1
x_2 = input_2 * input_2
cat_1 = layers.Concatenate(1)([x_1, x_2])
cat_2 = layers.Concatenate(1)([x_1, cat_1])
outputs = layers.Conv2D(filters=3,
kernel_size=3,
strides=2,
padding='same')(cat_2)
return tf.keras.Model(inputs=inputs, outputs=outputs)
def get_unet_like_test_model(input_shapes):
inputs = []
for i, input_shape in enumerate(input_shapes):
inputs.append(
tf.keras.Input(shape=input_shape[1:],
name='input_{}'.format(i + 1)))
# pylint: disable=unbalanced-tuple-unpacking
input_1, _ = inputs
conv_1 = layers.Conv2D(filters=8, kernel_size=1)(input_1)
conv_2 = layers.Conv2D(filters=16, kernel_size=1)(conv_1)
conv_3 = layers.Conv2D(filters=32, kernel_size=1)(conv_2)
conv_t_3 = layers.Conv2DTranspose(filters=16, kernel_size=1)(conv_3)
cat_1 = layers.Concatenate(0)([conv_t_3, conv_2])
conv_t_2 = layers.Conv2DTranspose(filters=8, kernel_size=1)(cat_1)
cat_2 = layers.Concatenate(0)([conv_t_2, conv_1])
outputs = layers.Conv2DTranspose(filters=4, kernel_size=1)(cat_2)
return tf.keras.Model(inputs=inputs, outputs=outputs)
def main():
config = Config()
# LOAD MODEL
backend.set_learning_phase(0)
age_model = load_model(model_pth=config.age_h5_path, name="age_model")
gender_model = load_model(model_pth=config.gender_h5_path,
name="gender_model")
emotion_model = load_model(model_pth=config.expr_h5_path,
name="emotion_model")
# COMBINE
_, height, width, depth = age_model.input.shape
cb_input = layers.Input(shape=(height, width, depth))
age_outs = age_model(cb_input)
gender_outs = gender_model(cb_input)
emo_outs = emotion_model(cb_input)
merged = layers.Concatenate()([age_outs, gender_outs, emo_outs])
cb_model = models.Model(inputs=cb_input, outputs=merged)
cb_model.summary()
# SAVE MODEL
cb_model.save(config.combine_model_h5_path)
print(
colored("[INFO] Combine model is DONE, saved at </ {} /> ".format(
config.combine_model_h5_path),
color='red',
attrs=['bold']))
# FREEZE
sess = backend.get_session()
converted_output_node_names = [node.op.name for node in cb_model.outputs]
print("[INFO] in: ", cb_model.inputs) # input_1_4:0
print("[INFO] out: ", cb_model.outputs) # concatenate/concat:0
constant_graph = graph_util.convert_variables_to_constants(
sess, sess.graph.as_graph_def(), converted_output_node_names)
freeze_folder = config.freeze_folder
name = os.path.split(config.combine_model_pb_path)[-1].split('.')[0]
tf.train.write_graph(constant_graph,
freeze_folder,
'%s.pbtxt' % name,
as_text=True)
tf.train.write_graph(constant_graph,
freeze_folder,
'%s.pb' % name,
as_text=False)
print(
colored("[INFO] convert model is success, saved at </ %s/%s.pb />" %
(freeze_folder, name),
color="cyan",
attrs=['bold']))
def new_dense_block(self, input_tensor, filters, name):
'''This method will create dense block with 1*1 and 3*3 dense conv layers'''
for i in range(filters):
x = self.new_dense_layer(input_tensor=input_tensor,
kernel_size=1,
k=4,
name=name + 'conv-1-' + str(i + 1))
merge_tensor = self.new_dense_layer(input_tensor=x,
kernel_size=3,
name=name + 'conv-3-' +
str(i + 1))
input_tensor = layers.Concatenate()([input_tensor, merge_tensor])
return input_tensor
def structureModel(self):
Inputs = layers.Input(shape=self._inputShape, batch_size=self._iBatchSize)
Con1 = layers.Conv2D(64, (3, 3), name='Con1', activation='relu', padding='SAME', input_shape=self._inputShape, strides=1)(Inputs)
Con2 = layers.Conv2D(64, (3, 3), name='Con2', activation='relu', padding='SAME', strides=1)(Con1)
Side1 = sideBranch(Con2, 1)
MaxPooling1 = layers.MaxPooling2D((2, 2), name='MaxPooling1', strides=2, padding='SAME')(Con2)
# outputs1
Con3 = layers.Conv2D(128, (3, 3), name='Con3', activation='relu', padding='SAME', strides=1)(MaxPooling1)
Con4 = layers.Conv2D(128, (3, 3), name='Con4', activation='relu', padding='SAME', strides=1)(Con3)
Side2 = sideBranch(Con4, 2)
MaxPooling2 = layers.MaxPooling2D((2, 2), name='MaxPooling2', strides=2, padding='SAME')(Con4)
# outputs2
Con5 = layers.Conv2D(256, (3, 3), name='Con5', activation='relu', padding='SAME', strides=1)(MaxPooling2)
Con6 = layers.Conv2D(256, (3, 3), name='Con6', activation='relu', padding='SAME', strides=1)(Con5)
Con7 = layers.Conv2D(256, (3, 3), name='Con7', activation='relu', padding='SAME', strides=1)(Con6)
Side3 = sideBranch(Con7, 4)
MaxPooling3 = layers.MaxPooling2D((2, 2), name='MaxPooling3', strides=2, padding='SAME')(Con7)
# outputs3
Con8 = layers.Conv2D(512, (3, 3), name='Con8', activation='relu', padding='SAME', strides=1)(MaxPooling3)
Con9 = layers.Conv2D(512, (3, 3), name='Con9', activation='relu', padding='SAME', strides=1)(Con8)
Con10 = layers.Conv2D(512, (3, 3), name='Con10', activation='relu', padding='SAME', strides=1)(Con9)
Side4 = sideBranch(Con10, 8)
MaxPooling4 = layers.MaxPooling2D((2, 2), name='MaxPooling4', strides=2, padding='SAME')(Con10)
# outputs4
Con11 = layers.Conv2D(512, (3, 3), name='Con11', activation='relu', padding='SAME', strides=1)(MaxPooling4)
Con12 = layers.Conv2D(512, (3, 3), name='Con12', activation='relu', padding='SAME', strides=1)(Con11)
Con13 = layers.Conv2D(512, (3, 3), name='Con13', activation='relu', padding='SAME', strides=1)(Con12)
Side5 = sideBranch(Con13, 16)
Fuse = layers.Concatenate(axis=-1)([Side1, Side2, Side3, Side4, Side5])
# learn fusion weight
Fuse = layers.Conv2D(1, (1, 1), name='Fuse', padding='SAME', use_bias=False, activation=None)(Fuse)
output1 = layers.Activation('sigmoid', name='output1')(Side1)
output2 = layers.Activation('sigmoid', name='output2')(Side2)
output3 = layers.Activation('sigmoid', name='output3')(Side3)
output4 = layers.Activation('sigmoid', name='output4')(Side4)
output5 = layers.Activation('sigmoid', name='output5')(Side5)
output6 = layers.Activation('sigmoid', name='output6')(Fuse)
outputs = [output1, output2, output3, output4, output5, output6]
self._pModel = Model(inputs=Inputs, outputs=outputs)
pAdam = optimizers.adam(lr=0.0001)
self._pModel.compile(loss={'output1': classBalancedSigmoidCrossEntropy,
'output2': classBalancedSigmoidCrossEntropy,
'output3': classBalancedSigmoidCrossEntropy,
'output4': classBalancedSigmoidCrossEntropy,
'output5': classBalancedSigmoidCrossEntropy,
'output6': classBalancedSigmoidCrossEntropy
}, optimizer=pAdam)
def create_dem_bc_aug(self, kernel_initializer = 'he_normal', img_flat_len = 1024, only_emb = False):
attr_input = layers.Input(shape = (self.attr_len,), name = 'attr')
word_emb = layers.Input(shape = (self.wv_len,), name = 'wv')
img_input = layers.Input(shape = (self.pixel, self.pixel, 3))
label = layers.Input(shape = (1,), name = 'label')
# img_flat_model = Model(inputs = self.img_model[0].inputs, outputs = self.img_model[0].get_layer(name = 'avg_pool').output)
imag_classifier = self.img_flat_model(img_input)
if self.attr_emb_transform == 'flat':
attr_emb = layers.Embedding(294, self.attr_emb_len)(attr_input)
attr_dense = layers.Flatten()(attr_emb) #layers.GlobalAveragePooling1D()(attr_emb)
elif self.attr_emb_transform == 'dense':
attr_dense = layers.Dense(self.attr_emb_len, use_bias = True, kernel_initializer=kernel_initializer,
kernel_regularizer = l2(1e-4), name = 'attr_dense')(attr_input)
if only_emb:
attr_word_emb = word_emb
else:
attr_word_emb = layers.Concatenate(name = 'attr_word_emb')([word_emb, attr_dense])
attr_word_emb_dense = self.full_connect_layer(attr_word_emb, hidden_dim = [
# int(img_flat_len * 4),
int(img_flat_len * 2),
int(img_flat_len * 1.5),
int(img_flat_len * 1.25),
# int(img_flat_len * 1.125),
int(img_flat_len)
], \
activation = 'relu', resnet = False, drop_out_ratio = 0.2)
# attr_word_emb_dense = self.full_connect_layer(attr_word_emb_dense, hidden_dim = [img_flat_len],
# activation = 'relu')
attr_x_img = layers.Lambda(lambda x: x[0] * x[1], name = 'attr_x_img')([attr_word_emb_dense, imag_classifier])
# attr_x_img = layers.Concatenate(name = 'attr_x_img')([attr_word_emb_dense, imag_classifier])
attr_img_input = layers.Input(shape = (img_flat_len,), name = 'attr_img_input')
# attr_img_input = layers.Input(shape = (img_flat_len * 2,), name = 'attr_img_input')
proba = self.full_connect_layer(attr_img_input, hidden_dim = [1], activation = 'sigmoid')
attr_img_model = Model(inputs = attr_img_input, outputs = proba, name = 'attr_x_img_model')
out = attr_img_model([attr_x_img])
# dem_bc_model = self.create_dem_bc(kernel_initializer = 'he_normal',
# img_flat_len = img_flat_len,
# only_emb = only_emb)
# attr_word_emb_dense, out = dem_bc_model([imag_classifier, attr_input, word_emb, label])
bc_loss = K.mean(binary_crossentropy(label, out))
model = Model([img_input, attr_input, word_emb, label], outputs = [attr_word_emb_dense, out, imag_classifier])
model.add_loss(bc_loss)
model.compile(optimizer=Adam(lr=1e-4), loss=None)
return model
def deconv2d(layer_input, skip_input, filters, f_size=4, dropout_rate=0):
"""Layer used during upsampling"""
output = UpSampling2D(size=2)(layer_input)
output = Conv2D(filters,
kernel_size=f_size,
strides=1,
padding='same',
activation='relu')(output)
if dropout_rate:
output = layers.Dropout(dropout_rate)(output)
output = InstanceNormalization()(output)
output = layers.Concatenate()([output, skip_input])
return output
def get_single_concat_test_model(input_shapes):
inputs = []
for i, input_shape in enumerate(input_shapes):
inputs.append(
tf.keras.Input(shape=input_shape[1:],
name='input_{}'.format(i + 1)))
# pylint: disable=unbalanced-tuple-unpacking
input_1, input_2 = inputs
x_1 = layers.Multiply()([input_1, input_1])
x_2 = layers.Multiply()([input_2, input_2])
outputs = layers.Concatenate(1)([x_1, x_2])
outputs = layers.Conv2D(filters=1, kernel_size=1)(outputs)
return tf.keras.Model(inputs=inputs, outputs=outputs)
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 rgr_headers(feature_list, num_anchors_list):
headers = []
for i, (feature,
num_anchors) in enumerate(zip(feature_list, num_anchors_list)):
header = seperable_conv2d(feature,
num_anchors * 4,
'rgr_header_{}'.format(i),
kernel_size=3)
# 打平
header = layers.Reshape(target_shape=(-1, 4),
name='rgr_header_flatten_{}'.format(i))(header)
headers.append(header)
# 拼接所有header
headers = layers.Concatenate(axis=1, name='rgr_header_concat')(
headers) # [B,num_anchors,4]
return headers
def residual_block(n_filters, input_layer):
g = layers.Conv2D(
filters=n_filters,
kernel_size=(3, 3),
padding='same',
)(input_layer)
g = tfa.layers.InstanceNormalization()(g)
g = layers.ReLU()(g)
g = layers.Conv2D(
filters=n_filters,
kernel_size=(3, 3),
padding='same',
)(g)
g = tfa.layers.InstanceNormalization()(g)
g = layers.Concatenate()([g, input_layer])
return g
