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 make_generator_model(dataset='mnist'):
""" implements generate.
Args:
dataset: mnist or cifar10 dataset. (default='mnist'). choice{'mnist', 'cifar'}.
Returns:
model.
"""
model = tf.keras.models.Sequential()
model.add(layers.Dense(256, input_dim=100))
model.add(layers.LeakyReLU(alpha=0.2))
model.add(layers.Dense(512))
model.add(layers.BatchNormalization())
model.add(layers.LeakyReLU(alpha=0.2))
model.add(layers.Dense(1024))
model.add(layers.BatchNormalization())
model.add(layers.LeakyReLU(alpha=0.2))
if dataset == 'mnist':
model.add(layers.Dense(28 * 28 * 1, activation='tanh'))
model.add(layers.Reshape((28, 28, 1)))
elif dataset == 'cifar':
model.add(layers.Dense(32 * 32 * 3, activation='tanh'))
model.add(layers.Reshape((32, 32, 3)))
return model
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_generator(latent_dim=50, nclasses=10):
label = layers.Input(shape=(1, ))
li = layers.Embedding(nclasses, 50)(label)
li = layers.Dense(7 * 7 * 1, activation="relu")(li)
li = layers.Reshape((7, 7, 1))(li)
noise = layers.Input(shape=(latent_dim, ))
n = layers.Dense(7 * 7 * 384, activation="relu")(noise)
n = layers.Reshape((7, 7, 384))(n)
input = layers.concatenate([n, li], axis=-1)
x = layers.Conv2DTranspose(filters=192,
kernel_size=5,
strides=2,
padding="same")(input)
x = layers.BatchNormalization()(x)
x = layers.ReLU()(x)
x = layers.Conv2DTranspose(filters=1,
kernel_size=5,
strides=2,
padding="same",
activation="tanh")(x)
model = tf.keras.Model([noise, label], x)
return model
def RSoftmax(x, filters, radix, groups, name):
bn_axis = 3 if backend.image_data_format() == 'channels_last' else 1
c = filters // radix // groups
shape = (groups, radix, c) if bn_axis == 3 else (groups, radix, c)
x = layers.Reshape(shape, name=name + '_0_attn_reshape')(x)
x = layers.Lambda(lambda x: tf.transpose(x, (0, 2, 1, 3)),
name=name + '_attn_transpose')(x)
x = layers.Softmax(axis=1, name=name + '_attn_softmax')(x)
shape = (1, 1, filters) if bn_axis == 3 else (filters, 1, 1)
x = layers.Reshape(shape, name=name + '_1_attn_reshape')(x)
return x
def __init__(self, height, width, channels, condition_dim):
# prepare real images
discriminator_input1 = layers.Input(shape=(height, width, channels))
x1 = layers.Conv2D(64, 5, padding='same')(discriminator_input1)
x1 = layers.Activation('tanh')(x1)
x1 = layers.MaxPooling2D(pool_size=(2, 2))(x1)
x1 = layers.Conv2D(128, 5)(x1)
x1 = layers.Activation('tanh')(x1)
x1 = layers.MaxPooling2D(pool_size=(2, 2))(x1)
# condition input from generator
discriminator_input2 = layers.Input(shape=(condition_dim, ))
x2 = layers.Dense(1024)(discriminator_input2)
x2 = layers.Activation('tanh')(x2)
x2 = layers.Dense(5 * 5 * 128)(x2)
x2 = layers.BatchNormalization()(x2)
x2 = layers.Activation('tanh')(x2)
x2 = layers.Reshape((5, 5, 128))(x2)
# concatenate 2 inputs
discriminator_input = layers.concatenate([x1, x2])
x = layers.Flatten()(discriminator_input)
x = layers.Dense(1024)(x)
x = layers.Activation('tanh')(x)
x = layers.Dense(1, activation='sigmoid')(x)
self.discriminator = tf.keras.models.Model(inputs=[discriminator_input1, discriminator_input2], outputs=x)
def generator_model(self):
model = tf.keras.Sequential()
# Linear block
model.add(kl.Dense(self.crop_size * 8 * 4 * 4 * 2, input_shape=(self.z_dim,),
kernel_initializer=tf.keras.initializers.random_normal(stddev=0.01)))
model.add(kl.Reshape((2, 4, 4, self.crop_size * 8)))
model.add(kl.BatchNormalization())
model.add(kl.ReLU())
# Convolution block 1
model.add(kl.Conv3DTranspose(filters=self.crop_size * 4, kernel_size=4, strides=2, padding='same',
kernel_initializer=self.conv_init, use_bias=True))
model.add(kl.BatchNormalization())
model.add(kl.ReLU())
# Convolution block 2
model.add(kl.Conv3DTranspose(filters=self.crop_size * 2, kernel_size=4, strides=2, padding='same',
kernel_initializer=self.conv_init, use_bias=True))
model.add(kl.BatchNormalization())
model.add(kl.ReLU())
# Convolution block 3
model.add(kl.Conv3DTranspose(filters=self.crop_size, kernel_size=4, strides=2, padding='same',
kernel_initializer=self.conv_init, use_bias=True))
model.add(kl.BatchNormalization())
model.add(kl.ReLU())
# Convolution block 4
model.add(kl.Conv3DTranspose(filters=3, kernel_size=4, strides=2, padding='same',
kernel_initializer=self.conv_init, use_bias=True, activation='tanh'))
return model
def _do_variational_autoencoding(input_signal, latent_dim=2):
x = layers.Conv2D(filters=64,
kernel_size=(3, 3),
strides=2,
padding='same')(input_signal)
x = layers.LeakyReLU()(x)
x = layers.Conv2D(filters=32,
kernel_size=(3, 3),
strides=2,
padding='same')(x)
x = layers.LeakyReLU()(x)
shape_before_flattening = K.int_shape(x)
x = layers.Flatten()(x)
x = layers.Dense(units=32, activation='relu')(x)
z_mean = layers.Dense(units=latent_dim)(x)
z_log_var = layers.Dense(units=latent_dim)(x)
epsilon = K.random_normal(shape=(K.shape(z_mean)[0], latent_dim),
mean=0.,
stddev=1.)
z = z_mean + K.exp(z_log_var) * epsilon
x = layers.Dense(np.prod(shape_before_flattening[1:]),
activation='relu')(z)
x = layers.Reshape(shape_before_flattening[1:])(x)
x = layers.Conv2DTranspose(filters=32,
kernel_size=(3, 3),
strides=2,
padding='same')(x)
x = layers.LeakyReLU()(x)
x = layers.Conv2DTranspose(filters=64,
kernel_size=(3, 3),
strides=2,
padding='same',
activation='relu')(x)
return x
def convnet_preprocessor(input_shapes,
image_shape,
output_size,
name="convnet_preprocessor",
make_picklable=True,
*args,
**kwargs):
inputs = [layers.Input(shape=input_shape) for input_shape in input_shapes]
concatenated_input = layers.Lambda(lambda x: tf.concat(x, axis=-1))(inputs)
image_size = np.prod(image_shape)
images_flat, input_raw = layers.Lambda(
lambda x: [x[..., :image_size], x[..., image_size:]])(
concatenated_input)
images = layers.Reshape(image_shape)(images_flat)
preprocessed_images = convnet(
input_shape=image_shape,
output_size=output_size - input_raw.shape[-1],
*args,
**kwargs,
)(images)
output = layers.Lambda(lambda x: tf.concat(x, axis=-1))(
[preprocessed_images, input_raw])
preprocessor = PicklableKerasModel(inputs, output, name=name)
return preprocessor
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 flatten(x, reshape=False):
"""
Flattens the input to two dimensional.
Parameters:
----------
x : keras.backend tensor/variable/symbol
Input tensor/variable/symbol.
reshape : bool, default False
Whether do reshape instead of flatten.
Returns
-------
keras.backend tensor/variable/symbol
Resulted tensor/variable/symbol.
"""
if not is_channels_first():
def channels_last_flatten(z):
z = K.permute_dimensions(z, pattern=(0, 3, 1, 2))
z = K.reshape(z, shape=(-1, np.prod(K.int_shape(z)[1:])))
updateshape(z)
return z
return nn.Lambda(channels_last_flatten)(x)
else:
if reshape:
x = nn.Reshape((-1, ))(x)
else:
x = nn.Flatten()(x)
return x
def __init__(self, image_shape: tuple, **kwargs):
conv_layers = [
ConvLayerConfig(stride=4,
filter_size=8,
nr_filters=32,
activation='relu',
batch_norm=False),
ConvLayerConfig(stride=2,
filter_size=4,
nr_filters=64,
activation='relu',
batch_norm=False),
ConvLayerConfig(stride=1,
filter_size=3,
nr_filters=64,
activation='relu',
batch_norm=False),
]
rgb = layers.Input(shape=image_shape, name='rgb_input', dtype=tf.uint8)
t = layers.Lambda(lambda x: K.cast(x, dtype='float32') / 255.)(rgb)
for cl in conv_layers:
t = layers.Conv2D(
filters=cl.nr_filters,
kernel_size=(cl.filter_size, cl.filter_size),
strides=(cl.stride, cl.stride),
activation=cl.activation,
)(t)
encoded = layers.Reshape(target_shape=(np.prod(t.shape[1:]), ))(t)
self.model = tf.keras.Model(inputs=[rgb], outputs=[encoded])
self.embedding_size = 3136
def rcnn(base_layers,
rois,
num_classes,
image_max_dim,
head_fn,
pool_size=(7, 7),
fc_layers_size=1024):
# RoiAlign
x = RoiAlign(image_max_dim, pool_size=pool_size)([base_layers, rois]) #
# 收缩维度
shared_layer = head_fn(x)
# 分类
class_logits = TimeDistributed(layers.Dense(num_classes,
activation='linear'),
name='rcnn_class_logits')(shared_layer)
# 回归(类别相关)
deltas = TimeDistributed(
layers.Dense(4 * num_classes, activation='linear'),
name='rcnn_deltas')(
shared_layer) # shape (batch_size,roi_num,4*num_classes)
# 变为(batch_size,roi_num,num_classes,4)
roi_num = backend.int_shape(deltas)[
1] # print("roi_num:{}".format(roi_num))
deltas = layers.Reshape((roi_num, num_classes, 4))(deltas)
return deltas, class_logits
def generator():
"""
Purpose of the Generator model is to images that looks real. During training,
the Generator progressively becomes better at creating images that look real.
The Generator model does upsampling to produces images from random noise. It
takes random noise as an input, then upsamples several times until reach
desired image size (in this case 28x28x1).
:return: The Generator model.
"""
model = keras.Sequential([
layers.Dense(units=7 * 7 * 256, use_bias=False, input_shape=(GEN_NOISE_INPUT_SHAPE,)),
layers.BatchNormalization(),
layers.LeakyReLU(),
layers.Reshape((7, 7, 256)),
layers.Conv2DTranspose(filters=128, kernel_size=(5, 5), strides=(1, 1), padding="same", use_bias=False),
layers.BatchNormalization(),
layers.LeakyReLU(),
layers.Conv2DTranspose(filters=64, kernel_size=(5, 5), strides=(2, 2), padding="same", use_bias=False),
layers.BatchNormalization(),
layers.LeakyReLU(),
layers.Conv2DTranspose(filters=1, kernel_size=(5, 5), strides=(2, 2), padding="same", use_bias=False,
activation="tanh"),
])
return model
def make_generator_model():
model = tf.keras.Sequential()
model.add(layers.Dense(7 * 7 * 256, use_bias=False, input_shape=(100, )))
model.add(layers.BatchNormalization())
model.add(layers.LeakyReLU())
model.add(layers.Reshape((7, 7, 256)))
assert model.output_shape == (None, 7, 7, 256
) # Note: None is the batch size
model.add(
layers.Conv2DTranspose(128, (5, 5),
strides=(1, 1),
padding='same',
use_bias=False))
assert model.output_shape == (None, 7, 7, 128)
model.add(layers.BatchNormalization())
model.add(layers.LeakyReLU())
model.add(
layers.Conv2DTranspose(64, (5, 5),
strides=(2, 2),
padding='same',
use_bias=False))
assert model.output_shape == (None, 14, 14, 64)
model.add(layers.BatchNormalization())
model.add(layers.LeakyReLU())
model.add(
layers.Conv2DTranspose(1, (5, 5),
strides=(2, 2),
padding='same',
use_bias=False,
activation='tanh'))
assert model.output_shape == (None, 28, 28, 1)
return model
def make_decoder_model():
""" decoder network structure.
Returns:
tf.keras.Model
"""
model = tf.keras.Sequential()
model.add(layers.Dense(7 * 7 * 64, activation=tf.nn.relu))
model.add(layers.Reshape((7, 7, 64)))
model.add(
layers.Conv2DTranspose(64, (3, 3),
strides=(2, 2),
padding='same',
activation=tf.nn.relu,
use_bias=False))
model.add(
layers.Conv2DTranspose(32, (3, 3),
strides=(2, 2),
padding='same',
activation=tf.nn.relu,
use_bias=False))
model.add(
layers.Conv2DTranspose(1, (3, 3),
strides=(1, 1),
padding='same',
activation=tf.nn.sigmoid,
use_bias=False))
return model
def SplitAttentionConv2D(x,
filters,
kernel_size,
stride=1,
padding=(0, 0),
groups=1,
use_bias=True,
radix=2,
name=None):
bn_axis = 3 if backend.image_data_format() == 'channels_last' else 1
reduction_factor = 4
inter_filters = max(filters * radix // reduction_factor, 32)
x = layers.ZeroPadding2D((padding, padding), name=name + '_splat_pad')(x)
x = layers.Conv2D(filters * radix,
kernel_size=kernel_size,
strides=stride,
groups=groups * radix,
use_bias=use_bias,
name=name + '_0_splat_conv')(x)
x = layers.BatchNormalization(axis=bn_axis,
epsilon=1.001e-5,
name=name + '_0_splat_bn')(x)
x = layers.Activation('relu', name=name + '_0_splat_relu')(x)
splits = layers.Lambda(lambda x: tf.split(x, radix, bn_axis),
name=name + '_0_splat_split')(x)
x = layers.Add(name=name + '_0_splat_add')(splits)
x = layers.GlobalAveragePooling2D(name=name + '_0_splat_pool')(x)
shape = (1, 1, filters) if bn_axis == 3 else (filters, 1, 1)
x = layers.Reshape(shape, name=name + '_0_splat_reshape')(x)
x = layers.Conv2D(inter_filters,
kernel_size=1,
groups=groups,
name=name + '_1_splat_conv')(x)
x = layers.BatchNormalization(axis=bn_axis,
epsilon=1.001e-5,
name=name + '_1_splat_bn')(x)
x = layers.Activation('relu', name=name + '_1_splat_relu')(x)
# Attention
x = layers.Conv2D(filters * radix,
kernel_size=1,
groups=groups,
name=name + '_2_splat_conv')(x)
x = RSoftmax(x, filters * radix, radix, groups, name=name)
x = layers.Lambda(lambda x: tf.split(x, radix, bn_axis),
name=name + '_1_splat_split')(x)
x = layers.Lambda(
lambda x: [tf.stack(x[0], axis=bn_axis),
tf.stack(x[1], axis=bn_axis)],
name=name + '_splat_stack')([splits, x])
x = layers.Multiply(name=name + '_splat_mult')(x)
x = layers.Lambda(lambda x: tf.unstack(x, axis=bn_axis),
name=name + '_splat_unstack')(x)
x = layers.Add(name=name + '_splat_add')(x)
return x
def make_generator_model():
model = tf.keras.Sequential()
model.add(
layers.Dense(4 * 4 * 1024,
use_bias=False,
input_shape=(100, ),
kernel_initializer=weight_initializer))
# model.add(layers.BatchNormalization())
model.add(layers.LeakyReLU(alpha=0.2))
model.add(layers.BatchNormalization())
model.add(layers.Reshape((4, 4, 1024)))
assert model.output_shape == (None, 4, 4, 1024)
#Upscale using Conv2DTranspose
# ToDo: Look into upsampling via interpolation and 2d Convolution
model.add(
layers.Conv2DTranspose(512, (5, 5),
strides=(2, 2),
padding='same',
use_bias=False,
kernel_initializer=weight_initializer))
assert model.output_shape == (None, 8, 8, 512)
# model.add(layers.BatchNormalization())
model.add(layers.LeakyReLU(alpha=0.2))
model.add(layers.BatchNormalization())
model.add(
layers.Conv2DTranspose(256, (5, 5),
strides=(2, 2),
padding='same',
use_bias=False,
kernel_initializer=weight_initializer))
assert model.output_shape == (None, 16, 16, 256)
# model.add(layers.BatchNormalization())
model.add(layers.LeakyReLU(alpha=0.2))
model.add(layers.BatchNormalization())
model.add(
layers.Conv2DTranspose(128, (5, 5),
strides=(2, 2),
padding='same',
use_bias=False,
kernel_initializer=weight_initializer))
assert model.output_shape == (None, 32, 32, 128)
# model.add(layers.BatchNormalization())
model.add(layers.LeakyReLU(alpha=0.2))
model.add(layers.BatchNormalization())
model.add(
layers.Conv2DTranspose(3, (5, 5),
strides=(2, 2),
padding='same',
use_bias=False,
activation='tanh',
kernel_initializer=weight_initializer))
assert model.output_shape == (None, 64, 64, 3)
return model
def get_model():
model = models.Sequential()
model.add(layers.Reshape((30, 30, 30, 1), input_shape=(30, 30, 30, 1)))
model.add(layers.Conv3D(16, 6, strides=2, activation='relu', padding='same'))
model.add(layers.Conv3D(64, 5, strides=2, activation='relu', padding='same'))
model.add(layers.Conv3D(64, 5, strides=2, activation='relu'))
model.add(layers.Flatten())
model.add(layers.Dense(10, activation='softmax'))
return model
def regression_sub_net(num_anchor=9):
"""Creates a regression sub-network for the RetinaNet.
Args:
num_anchor (int, optional): number of anchor boxes. Defaults to 9.
Returns:
'Model' object: regression sub-network.
"""
model = models.Sequential()
model.add(
layers.Conv2D(
256,
kernel_size=3,
strides=1,
padding='same',
activation='relu',
kernel_regularizer=regularizers.l2(0.0001),
kernel_initializer=tf.random_normal_initializer(stddev=0.01)))
model.add(
layers.Conv2D(
256,
kernel_size=3,
strides=1,
padding='same',
activation='relu',
kernel_regularizer=regularizers.l2(0.0001),
kernel_initializer=tf.random_normal_initializer(stddev=0.01)))
model.add(
layers.Conv2D(
256,
kernel_size=3,
strides=1,
padding='same',
activation='relu',
kernel_regularizer=regularizers.l2(0.0001),
kernel_initializer=tf.random_normal_initializer(stddev=0.01)))
model.add(
layers.Conv2D(
256,
kernel_size=3,
strides=1,
padding='same',
activation='relu',
kernel_regularizer=regularizers.l2(0.0001),
kernel_initializer=tf.random_normal_initializer(stddev=0.01)))
model.add(
layers.Conv2D(
4 * num_anchor,
kernel_size=3,
strides=1,
padding='same',
kernel_regularizer=regularizers.l2(0.0001),
kernel_initializer=tf.random_normal_initializer(stddev=0.01)))
model.add(layers.Reshape(
(-1, 4))) # the output dimension is [batch, #anchor, 4]
return model
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 classification_sub_net(num_classes, num_anchor=9):
"""Creates an object classification sub-network for the RetinaNet.
Args:
num_classes (int): number of classes.
num_anchor (int, optional): number of anchor boxes. Defaults to 9.
Returns:
'Model' object: classification sub-network.
"""
model = models.Sequential()
model.add(
layers.Conv2D(
256,
kernel_size=3,
strides=1,
padding='same',
activation='relu',
kernel_initializer=tf.random_normal_initializer(stddev=0.01)))
model.add(
layers.Conv2D(
256,
kernel_size=3,
strides=1,
padding='same',
activation='relu',
kernel_initializer=tf.random_normal_initializer(stddev=0.01)))
model.add(
layers.Conv2D(
256,
kernel_size=3,
strides=1,
padding='same',
activation='relu',
kernel_initializer=tf.random_normal_initializer(stddev=0.01)))
model.add(
layers.Conv2D(
256,
kernel_size=3,
strides=1,
padding='same',
activation='relu',
kernel_initializer=tf.random_normal_initializer(stddev=0.01)))
model.add(
layers.Conv2D(
num_classes * num_anchor,
kernel_size=3,
strides=1,
padding='same',
activation='sigmoid',
kernel_initializer=tf.random_normal_initializer(stddev=0.01),
bias_initializer=tf.initializers.constant(np.log(1 / 99))))
model.add(layers.Reshape(
(-1,
num_classes))) # the output dimension is [batch, #anchor, #classes]
return model
def _se_block(inputs, filters, se_ratio, prefix):
x = layers.GlobalAveragePooling2D(name=prefix +
'squeeze_excite/AvgPool')(inputs)
if backend.image_data_format() == 'channels_first':
x = layers.Reshape((filters, 1, 1))(x)
else:
x = layers.Reshape((1, 1, filters))(x)
x = layers.Conv2D(_depth(filters * se_ratio),
kernel_size=1,
padding='same',
name=prefix + 'squeeze_excite/Conv')(x)
x = layers.ReLU(name=prefix + 'squeeze_excite/Relu')(x)
x = layers.Conv2D(filters,
kernel_size=1,
padding='same',
name=prefix + 'squeeze_excite/Conv_1')(x)
x = hard_sigmoid(x)
x = layers.Multiply(name=prefix + 'squeeze_excite/Mul')([inputs, x])
return x
def __init__(self,
image_shape: tuple,
embedding_size: int = 16,
conv_layers: Optional[List[ConvLayerConfig]] = None,
l2_param_penalty: float = 0.00):
pn = tf.keras.regularizers.l2(
l2_param_penalty) if l2_param_penalty > 0 else None
if conv_layers is None:
conv_layers = [
ConvLayerConfig(stride=2,
filter_size=3,
nr_filters=8,
activation='elu',
batch_norm=True),
ConvLayerConfig(stride=2,
filter_size=3,
nr_filters=int(image_shape[-1]),
activation='elu',
batch_norm=True),
]
img_s = [int(x) for x in image_shape[:2]]
for cl in conv_layers:
img_s = [s / cl.stride for s in img_s]
initial_shape = (int(img_s[0]), int(img_s[1]), 1)
assert np.allclose(
initial_shape[:2],
img_s[:2]), 'eventual size divided by strides should be an integer'
encoding = layers.Input(shape=(embedding_size, ),
name='embedding_input',
dtype=tf.float32)
e = layers.Dense(units=np.prod(initial_shape),
activation='elu')(encoding)
e = layers.Reshape(target_shape=initial_shape)(e)
for cl in conv_layers:
e = layers.Conv2DTranspose(filters=cl.nr_filters,
kernel_size=(cl.filter_size,
cl.filter_size),
strides=(cl.stride, cl.stride),
data_format='channels_last',
padding='same',
activation=cl.activation,
kernel_regularizer=pn)(e)
if cl.batch_norm:
e = layers.BatchNormalization()(e)
rgb_norm = e
assert rgb_norm.shape[1:] == image_shape
self.model = tf.keras.Model(inputs=[encoding], outputs=[rgb_norm])
def define_generator(latent_dim=50, nclasses=10):
label = layers.Input(shape=(1, ))
li = layers.Embedding(nclasses, 50)(label)
li = layers.Dense(7*7)(li)
li = layers.Reshape((7, 7, 1))(li)
in_lat = layers.Input((latent_dim,))
lat = layers.Dense(7*7*128)(in_lat)
lat = layers.Reshape((7, 7, 128))(lat)
x = layers.concatenate([li, lat], axis=-1)
x = layers.Conv2DTranspose(filters=128, kernel_size=4, strides=2, padding="same")(x)
x = layers.LeakyReLU(alpha=0.2)(x)
x = layers.Conv2DTranspose(filters=128, kernel_size=4, strides=2, padding="same")(x)
x = layers.LeakyReLU(alpha=0.2)(x)
out = layers.Conv2D(filters=1, kernel_size=7, activation="tanh", padding="same")(x)
model = tf.keras.Model([label, in_lat], out)
return model
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 get_model_with_reshapes_and_concats(batch_size=None):
inputs = layers.Input((64, ), batch_size=batch_size)
x = tf.reshape(inputs, (32, -1))
x = layers.Reshape((16, -1))(x)
ones = tf.ones_like(x)
t1 = layers.concatenate([x, ones])
# pylint: disable=E1120,E1123
t2 = tf.concat([x, ones], axis=-1)
y = tf.concat([t1, t2], axis=-1)
y = tf.transpose(y, [2, 0, 1])
y = tf.keras.layers.Flatten()(y)
return models.Model(inputs, y, name='ModelWithReshape')
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.leaky_relu,
use_bias=False,
name='fc1')(img_input)
x = layers.BatchNormalization(name='bn1')(x)
x = layers.Reshape(target_shape=(7, 7, 256), name='reshape1')(x)
x = layers.Conv2DTranspose(128, (5, 5),
strides=(1, 1),
activation=tf.nn.leaky_relu,
padding='same',
use_bias=False,
name='deconv1')(x)
x = layers.BatchNormalization(name='bn2')(x)
x = layers.Conv2DTranspose(64, (5, 5),
strides=(2, 2),
activation=tf.nn.leaky_relu,
padding='same',
use_bias=False,
name='deconv2')(x)
x = layers.BatchNormalization(name='bn3')(x)
x = layers.Conv2DTranspose(1, (5, 5),
strides=(2, 2),
activation=tf.nn.tanh,
padding='same',
use_bias=False,
name='deconv3')(x)
if input_tensor is not None:
inputs = utils.get_source_inputs(input_tensor)
else:
inputs = img_input
model = models.Model(inputs, x, name='Generator_model')
return model
def _classification_sub_net(num_classes, num_anchor=9):
model = models.Sequential()
model.add(
layers.Conv2D(
256,
kernel_size=3,
strides=1,
padding='same',
activation='relu',
kernel_regularizer=regularizers.l2(0.0001),
kernel_initializer=tf.random_normal_initializer(stddev=0.01)))
model.add(
layers.Conv2D(
256,
kernel_size=3,
strides=1,
padding='same',
activation='relu',
kernel_regularizer=regularizers.l2(0.0001),
kernel_initializer=tf.random_normal_initializer(stddev=0.01)))
model.add(
layers.Conv2D(
256,
kernel_size=3,
strides=1,
padding='same',
activation='relu',
kernel_regularizer=regularizers.l2(0.0001),
kernel_initializer=tf.random_normal_initializer(stddev=0.01)))
model.add(
layers.Conv2D(
256,
kernel_size=3,
strides=1,
padding='same',
activation='relu',
kernel_regularizer=regularizers.l2(0.0001),
kernel_initializer=tf.random_normal_initializer(stddev=0.01)))
model.add(
layers.Conv2D(
num_classes * num_anchor,
kernel_size=3,
strides=1,
padding='same',
activation='sigmoid',
kernel_regularizer=regularizers.l2(0.0001),
kernel_initializer=tf.random_normal_initializer(stddev=0.01),
bias_initializer=tf.initializers.constant(np.log(1 / 99))))
model.add(layers.Reshape(
(-1,
num_classes))) # the output dimension is [batch, #anchor, #classes]
return model
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)
