def _build_residual_block(self, x, index):
# mc = self.config.model
mc = self.config
in_x = x
res_name = "res" + str(index)
x = Conv2D(filters=mc.cnn_filter_num,
kernel_size=mc.cnn_filter_size,
padding="same",
data_format="channels_first",
use_bias=False,
kernel_regularizer=l2(mc.l2_reg),
name=res_name + "_conv1-" + str(mc.cnn_filter_size) + "-" +
str(mc.cnn_filter_num))(x)
x = BatchNormalization(axis=1, name=res_name + "_batchnorm1")(x)
x = Activation("relu", name=res_name + "_relu1")(x)
x = Conv2D(filters=mc.cnn_filter_num,
kernel_size=mc.cnn_filter_size,
padding="same",
data_format="channels_first",
use_bias=False,
kernel_regularizer=l2(mc.l2_reg),
name=res_name + "_conv2-" + str(mc.cnn_filter_size) + "-" +
str(mc.cnn_filter_num))(x)
x = BatchNormalization(axis=1,
name="res" + str(index) + "_batchnorm2")(x)
x = Add(name=res_name + "_add")([in_x, x])
x = Activation("relu", name=res_name + "_relu2")(x)
return x
def build(self):
"""
Builds the full Keras model and stores it in self.model.
"""
mc = self.config
in_x = x = Input((12, 8, 8))
# (batch, channels, height, width)
x = Conv2D(filters=mc.cnn_filter_num,
kernel_size=mc.cnn_first_filter_size,
padding="same",
data_format="channels_first",
use_bias=False,
kernel_regularizer=l2(mc.l2_reg),
name="input_conv-" + str(mc.cnn_first_filter_size) + "-" +
str(mc.cnn_filter_num))(x)
x = BatchNormalization(axis=1, name="input_batchnorm")(x)
x = Activation("relu", name="input_relu")(x)
for i in range(mc.res_layer_num):
x = self._build_residual_block(x, i + 1)
res_out = x
# for policy output
x = Conv2D(filters=2,
kernel_size=1,
data_format="channels_first",
use_bias=False,
kernel_regularizer=l2(mc.l2_reg),
name="policy_conv-1-2")(res_out)
x = BatchNormalization(axis=1, name="policy_batchnorm")(x)
x = Activation("relu", name="policy_relu")(x)
x = Flatten(name="policy_flatten")(x)
policy_out = Dense(self.config.n_labels,
kernel_regularizer=l2(mc.l2_reg),
activation="softmax",
name="policy_out")(x)
# for value output
x = Conv2D(filters=4,
kernel_size=1,
data_format="channels_first",
use_bias=False,
kernel_regularizer=l2(mc.l2_reg),
name="value_conv-1-4")(res_out)
x = BatchNormalization(axis=1, name="value_batchnorm")(x)
x = Activation("relu", name="value_relu")(x)
x = Flatten(name="value_flatten")(x)
x = Dense(mc.value_fc_size,
kernel_regularizer=l2(mc.l2_reg),
activation="relu",
name="value_dense")(x)
value_out = Dense(1,
kernel_regularizer=l2(mc.l2_reg),
activation="tanh",
name="value_out")(x)
self.model = Model(in_x, [policy_out, value_out], name="chess_model")
def InceptionBlock_v2(inputs, num_filters, kernel_size, activation, padding,
strides, kernel_initializer="he_normal"):
# print("testline2:",inputs.shape)
cut = inputs
layer = Conv2D(int(num_filters / 4), 1,
padding=padding,
strides=strides,
activation=activation,
kernel_initializer=kernel_initializer)(inputs)
layer = Conv2D(int(num_filters / 4), kernel_size,
padding=padding,
activation=activation,
strides=strides,
kernel_initializer=kernel_initializer)(layer)
layer = Conv2D(num_filters, 1,
padding=padding,
strides=strides,
activation=activation,
kernel_initializer=kernel_initializer)(layer)
layer += cut
# print("testline22:", layer.shape)
return layer
def __init__(self, filters):
super(DoubleConvBlock, self).__init__()
self.deconv = Conv2DTranspose(filter=filters[0],
kernel_size=(3, 3),
strides=1,
padding="same")
self.concat = Concatenate()
self.conv1 = Conv2D(
filter=filters[1],
kernel_size=(3, 3),
strides=1,
padding="same",
)
self.bn1 = BatchNormalization()
self.act1 = Activation("relu")
self.conv2 = Conv2D(
filter=filters[2],
kernel_size=(3, 3),
strides=1,
padding="same",
)
self.bn2 = BatchNormalization()
self.act2 = Activation("relu")
def discriminator_model():
"""Build discriminator architecture."""
n_layers, use_sigmoid = 3, False
inputs = Input(shape=input_shape_discriminator)
x = Conv2D(filters=ndf, kernel_size=(4, 4), strides=2, padding='same')(inputs)
x = LeakyReLU(0.2)(x)
nf_mult, nf_mult_prev = 1, 1
for n in range(n_layers):
nf_mult_prev, nf_mult = nf_mult, min(2**n, 8)
x = Conv2D(filters=ndf*nf_mult, kernel_size=(4, 4), strides=2, padding='same')(x)
x = BatchNormalization()(x)
x = LeakyReLU(0.2)(x)
nf_mult_prev, nf_mult = nf_mult, min(2**n_layers, 8)
x = Conv2D(filters=ndf*nf_mult, kernel_size=(4, 4), strides=1, padding='same')(x)
x = BatchNormalization()(x)
x = LeakyReLU(0.2)(x)
x = Conv2D(filters=1, kernel_size=(4, 4), strides=1, padding='same')(x)
if use_sigmoid:
x = Activation('sigmoid')(x)
x = Flatten()(x)
x = Dense(1024, activation='tanh')(x)
x = Dense(1, activation='sigmoid')(x)
model = Model(inputs=inputs, outputs=x, name='Discriminator')
return model
def initialize_model():
model = Sequential()
model.add(
Conv2D(40, 11, strides=1, padding='same', input_shape=(1, 1024, 4)))
model.add(BatchNormalization(axis=-1))
model.add(Activation('relu'))
model.add(Conv2D(40, 11, strides=1, padding='same'))
model.add(BatchNormalization(axis=-1))
model.add(Activation('relu'))
model.add(MaxPooling2D(pool_size=(1, 64)))
model.add(Flatten())
model.add(Dense(units=500))
model.add(Dense(units=640))
model.add(Reshape((1, 16, 40)))
model.add(Conv2DTranspose(40, 11, strides=(1, 64), padding='same'))
model.add(BatchNormalization(axis=-1))
model.add(Activation('relu'))
model.add(Conv2DTranspose(40, 11, strides=(1, 1), padding='same'))
model.add(BatchNormalization(axis=-1))
model.add(Activation('relu'))
model.add(Conv2D(4, 11, strides=1, padding='same', activation='sigmoid'))
model.summary()
model.compile(optimizer='adam', loss='mse')
return model
def create_posla_net(self, raw=120, column=320, channel=1):
# model setting
inputShape = (raw, column, channel)
activation = 'relu'
keep_prob_conv = 0.25
keep_prob_dense = 0.5
# init = 'glorot_normal'
# init = 'he_normal'
init = 'he_uniform'
chanDim = -1
classes = 3
model = Sequential()
# CONV => RELU => POOL
model.add(
Conv2D(3, (3, 3),
padding="valid",
input_shape=inputShape,
kernel_initializer=init,
activation=activation))
model.add(BatchNormalization(axis=chanDim))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(
Conv2D(9, (3, 3),
padding="valid",
kernel_initializer=init,
activation=activation))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(
Conv2D(18, (3, 3),
padding="valid",
kernel_initializer=init,
activation=activation))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(
Conv2D(32, (3, 3),
padding="valid",
kernel_initializer=init,
activation=activation))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Flatten())
model.add(Dense(80, kernel_initializer=init, activation=activation))
model.add(Dropout(keep_prob_dense))
model.add(Dense(15, kernel_initializer=init, activation=activation))
model.add(Dropout(keep_prob_dense))
# softmax classifier
model.add(Dense(classes, activation='softmax'))
self.model = model
def build_generator(channels, num_classes, latent_dim):
model = Sequential()
model.add(Dense(128 * 7 * 7, activation="relu", input_dim=latent_dim))
model.add(Reshape((7, 7, 128)))
model.add(BatchNormalization(momentum=0.8))
model.add(UpSampling2D())
#7x7x128
model.add(Conv2D(128, kernel_size=3, padding="same"))
model.add(Activation("relu"))
model.add(BatchNormalization(momentum=0.8))
model.add(UpSampling2D())
#14x14x128
model.add(Conv2D(64, kernel_size=3, padding="same"))
model.add(Activation("relu"))
model.add(BatchNormalization(momentum=0.8))
#28x28x64
model.add(Conv2D(channels, kernel_size=3, padding='same'))
model.add(Activation("tanh"))
#28x28x3
model.summary()
noise = Input(shape=(latent_dim, ))
label = Input(shape=(1, ), dtype='int32')
label_embedding = Flatten()(Embedding(num_classes, latent_dim)(label))
model_input = multiply([noise, label_embedding])
img = model(model_input)
return Model([noise, label], img)
def extract_layer(input_tensor=None):
x = TimeDistributed(
Conv2D(64, (3, 3),
activation='relu',
padding='same',
name='block1_conv1',
trainable=True))(input_tensor)
x = TimeDistributed(
Conv2D(64, (3, 3),
activation='relu',
padding='same',
name='block1_conv2',
trainable=True))(x)
x = TimeDistributed(
MaxPooling2D((2, 2), strides=(2, 2), name='block1_pool'))(x)
# Block 2
x = TimeDistributed(
Conv2D(128, (3, 3),
activation='relu',
padding='same',
name='block2_conv1',
trainable=True))(x)
x = TimeDistributed(
Conv2D(128, (3, 3),
activation='relu',
padding='same',
name='block2_conv2',
trainable=True))(x)
x = TimeDistributed(
MaxPooling2D((2, 2), strides=(2, 2), name='block2_pool'))(x)
return x
def generator(input_shape, upscale_times=2):
gen_input = Input(shape=input_shape)
model = Conv2D(filters=64, kernel_size=9, strides=1,
padding="same")(gen_input)
model = PReLU(alpha_initializer='zeros',
alpha_regularizer=None,
alpha_constraint=None,
shared_axes=[1, 2])(model)
gen_model = model
# Using 16 Residual Blocks
for index in range(8):
model = res_block_gen(model, 3, 64, 1)
model = Conv2D(filters=64, kernel_size=3, strides=1, padding="same")(model)
model = BatchNormalization(momentum=0.5)(model)
model = add([gen_model, model])
# Using 2 UpSampling Blocks
for index in range(upscale_times):
model = up_sampling_block(model, 3, 256, 1)
model = Conv2D(filters=3, kernel_size=9, strides=1, padding="same")(model)
model = Activation('tanh')(model)
generator_model = Model(inputs=gen_input, outputs=model)
return generator_model
def __init__(self, filter_sizes):
super(DownsampleBlock, self).__init__()
self.conv1 = Conv2D(
filter=filter_sizes[0],
kernel_size=(3, 3),
strides=1,
padding="same",
)
self.bn1 = BatchNormalization()
self.act1 = Activation("relu")
self.conv2 = Conv2D(
filter=filter_sizes[1],
kernel_size=(3, 3),
strides=1,
padding="same",
)
self.bn2 = BatchNormalization()
self.act2 = Activation("relu")
self.mp = MaxPooling2D(pool_size=(2, 2))
def build_generator(self):
# layers, kernel_size, strides should be changed wisely to fit the output size.
'''
This function is used to define the generator of model(DCGAN).
'''
model = Sequential()
model.add(Conv2D(128, kernel_size = 5, strides = 1, padding = 'same', use_bias = True, kernel_initializer = RandomNormal(stddev = 0.02)))
model.add(BatchNormalization(momentum = 0.8))
model.add(Activation("relu"))
#model.add(UpSampling2D())
model.add(Conv2D(64, kernel_size = 5, strides = 1, padding = 'same', use_bias = True, kernel_initializer = RandomNormal(stddev = 0.02)))
model.add(BatchNormalization(momentum = 0.8))
model.add(Activation("relu"))
#model.add(UpSampling2D())
model.add(Conv2DTranspose(self.img_channels, kernel_size = 5, strides = 1, padding = 'same', use_bias = True, kernel_initializer = RandomNormal(stddev = 0.02)))
#model.add(BatchNormalization(momentum = 0.8))
model.add(Activation("tanh"))
#model.summary()
image = Input(shape = (self.img_size, self.img_size, self.img_channels))
img_output = model(image)
return Model(image, img_output)
def build_discriminator(self):
'''
This function is used to define the discriminator of model(DCGAN).
'''
model = Sequential()
model.add(Reshape((self.img_size, self.img_size, self.img_channels)))
model.add(Conv2D(32, kernel_size = 5, strides = 2, padding = 'same', use_bias = True, kernel_initializer = RandomNormal(stddev = 0.02)))
model.add(LeakyReLU(alpha = 0.2))
model.add(Dropout(rate = 0.25))
model.add(Conv2D(64, kernel_size = 5, strides = 2, padding = 'same', use_bias = True, kernel_initializer = RandomNormal(stddev = 0.02)))
#model.add(ZeroPadding2D(padding = ((0,1),(0,1))))
model.add(BatchNormalization(momentum = 0.99))
model.add(LeakyReLU(alpha = 0.2))
model.add(Dropout(rate = 0.25))
model.add(Conv2D(128, kernel_size = 5, strides = 2, padding = 'same', use_bias = True, kernel_initializer = RandomNormal(stddev = 0.02)))
#model.add(ZeroPadding2D(padding = ((0,1),(0,1))))
model.add(BatchNormalization(momentum = 0.99))
model.add(LeakyReLU(alpha = 0.2))
model.add(Dropout(rate = 0.25))
model.add(Conv2D(128, kernel_size = 5, strides = 2, padding = 'same', use_bias = True, kernel_initializer = RandomNormal(stddev = 0.02)))
model.add(BatchNormalization(momentum = 0.99))
model.add(LeakyReLU(alpha = 0.2))
model.add(Dropout(rate = 0.25))
model.add(Flatten())
model.add(Dense(1, activation = 'sigmoid'))
img = Input(shape = (self.img_size, self.img_size, self.img_channels))
output_ = model(img)
return Model(img, output_)
def inception_resnet_v2_C(input, scale_residual=True):
channel_axis = -1
# Input is relu activation
init = input
ir1 = Conv2D(192, (1, 1), activation='relu', padding='same')(input)
ir2 = Conv2D(192, (1, 1), activation='relu', padding='same')(input)
ir2 = Conv2D(224, (1, 3), activation='relu', padding='same')(ir2)
ir2 = Conv2D(256, (3, 1), activation='relu', padding='same')(ir2)
ir_merge = merge.concatenate([ir1, ir2], axis=channel_axis)
ir_conv = Conv2D(backend.int_shape(input)[channel_axis], (1, 1),
activation='relu')(ir_merge)
out = Lambda(lambda inputs, scale: inputs[0] + inputs[1] * scale,
output_shape=backend.int_shape(input)[1:],
arguments={'scale': 0.1})([input, ir_conv])
# ir_conv = Conv2D(2144, (1, 1), activation='linear', padding='same')(ir_merge)
# if scale_residual: ir_conv = Lambda(lambda x: x * 0.1)(ir_conv)
# out = merge.concatenate([init, ir_conv], axis=channel_axis)
out = BatchNormalization(axis=channel_axis)(out)
out = Activation("relu")(out)
return out
def build_critic(self):
model = Sequential()
model.add(
Conv2D(16,
kernel_size=3,
strides=2,
input_shape=self.img_shape,
padding="same"))
model.add(LeakyReLU(alpha=0.2))
model.add(Dropout(0.25))
model.add(Conv2D(32, kernel_size=3, strides=2, padding="same"))
model.add(ZeroPadding2D(padding=((0, 1), (0, 1))))
model.add(BatchNormalization(momentum=0.8))
model.add(LeakyReLU(alpha=0.2))
model.add(Dropout(0.25))
model.add(Conv2D(64, kernel_size=3, strides=2, padding="same"))
model.add(BatchNormalization(momentum=0.8))
model.add(LeakyReLU(alpha=0.2))
model.add(Dropout(0.25))
model.add(Conv2D(128, kernel_size=3, strides=1, padding="same"))
model.add(BatchNormalization(momentum=0.8))
model.add(LeakyReLU(alpha=0.2))
model.add(Dropout(0.25))
model.add(Flatten())
model.add(Dense(1))
model.summary()
img = Input(shape=self.img_shape)
validity = model(img)
return Model(img, validity)
def myModel():
no_Of_Filters = 60
size_of_Filter = (5, 5)
size_of_Filter_2 = (3, 3)
size_of_pool = (2, 2)
no_Of_Nodes = 500
model = Sequential()
model.add((Conv2D(no_Of_Filters,
size_of_Filter,
input_shape=(imageDimesions[0], imageDimesions[1], 1),
activation='relu')))
model.add((Conv2D(no_Of_Filters, size_of_Filter, activation='relu')))
model.add(MaxPooling2D(pool_size=size_of_pool))
model.add((Conv2D(no_Of_Filters // 2, size_of_Filter_2,
activation='relu')))
model.add((Conv2D(no_Of_Filters // 2, size_of_Filter_2,
activation='relu')))
model.add(MaxPooling2D(pool_size=size_of_pool))
model.add(Dropout)
model.add(Flatten())
model.add(Dense(no_Of_Nodes, activation='relu'))
model.add(Dropout(0.5))
model.add(Dense(noOfClasses, activation='softmax'))
model.compile(Adam(lr=0.001),
loss='categorical_crossentropy',
metrics=['accuracy'])
return model
def __init__(self, num_templates=10, **kwargs):
WeightedMixIn.__init__(self)
Conv2D.__init__(self, **kwargs)
self.num_templates = num_templates
self.add_template_variable(weight_name="kernel")
self.add_template_variable(weight_name="bias")
mixture_input_spec = InputSpec(ndim=1)
self.input_spec = (self.input_spec, mixture_input_spec)
def T_trans(T, T_F, H, W):
T_in = Input(shape=(T + 7, H, W))
T_in_p = Permute((2, 3, 1))(T_in)
T_mid = Conv2D(filters=T_F, kernel_size=(1, 1), padding="same")(T_in_p)
T_act = Activation('relu')(T_mid)
T_fin = Conv2D(filters=1, kernel_size=(1, 1), padding="same")(T_act)
T_mul = Activation('relu')(T_fin)
T_model = Model(inputs=T_in, outputs=T_mul)
return T_model
def create_keras_model(inputShape, nClasses, output_activation='linear'):
"""
SegNet model
----------
inputShape : tuple
Tuple with the dimensions of the input data (ny, nx, nBands).
nClasses : int
Number of classes.
"""
filter_size = 64
kernel = (3, 3)
pad = (1, 1)
pool_size = (2, 2)
inputs = Input(shape=inputShape, name='image')
# Encoder
x = Conv2D(64, kernel, padding='same')(inputs)
x = BatchNormalization()(x)
x = Activation('relu')(x)
x = MaxPooling2D(pool_size=pool_size)(x)
x = Conv2D(128, kernel, padding='same')(x)
x = BatchNormalization()(x)
x = Activation('relu')(x)
x = MaxPooling2D(pool_size=pool_size)(x)
x = Conv2D(256, kernel, padding='same')(x)
x = BatchNormalization()(x)
x = Activation('relu')(x)
x = MaxPooling2D(pool_size=pool_size)(x)
x = Conv2D(512, kernel, padding='same')(x)
x = BatchNormalization()(x)
x = Activation('relu')(x)
# Decoder
x = Conv2D(512, kernel, padding='same')(x)
x = BatchNormalization()(x)
x = UpSampling2D(size=pool_size)(x)
x = Conv2D(256, kernel, padding='same')(x)
x = BatchNormalization()(x)
x = UpSampling2D(size=pool_size)(x)
x = Conv2D(128, kernel, padding='same')(x)
x = BatchNormalization()(x)
x = UpSampling2D(size=pool_size)(x)
x = Conv2D(64, kernel, padding='same')(x)
x = BatchNormalization()(x)
x = Conv2D(nClasses, (1, 1), padding='valid')(x)
outputs = Activation(output_activation, name='output')(x)
model = Model(inputs=inputs, outputs=outputs, name='segnet')
return model
def create_nvidia_net(self, raw=120, column=320, channel=1):
print('create nvidia model!!')
input_shape = (raw, column, channel)
activation = 'relu'
keep_prob = 0.5
keep_prob_dense = 0.5
classes = 3
model = Sequential()
model.add(
Conv2D(24, (5, 5),
input_shape=input_shape,
padding="valid",
strides=(2, 2)))
model.add(Activation(activation))
model.add(Dropout(keep_prob))
model.add(Conv2D(36, (5, 5), padding="valid", strides=(2, 2)))
model.add(Activation(activation))
model.add(Dropout(keep_prob))
model.add(Conv2D(48, (5, 5), padding="valid", strides=(2, 2)))
model.add(Activation(activation))
model.add(Dropout(keep_prob))
model.add(Conv2D(64, (3, 3)))
model.add(Activation(activation))
model.add(Dropout(keep_prob))
model.add(Conv2D(64, (3, 3)))
model.add(Activation(activation))
model.add(Dropout(keep_prob))
# FC
model.add(Flatten())
model.add(Dense(100))
model.add(Dropout(keep_prob_dense))
model.add(Dense(50))
model.add(Dropout(keep_prob_dense))
model.add(Dense(10))
model.add(Dropout(keep_prob_dense))
model.add(Dense(classes))
model.add(Activation('softmax'))
self.model = model
def residual(inputs, filter_size, kernel):
x = Conv2D(filter_size,
kernel,
padding='same',
kernel_initializer='he_normal')(inputs)
x = BatchNormalization()(x)
x = Activation('relu')(x)
x = Conv2D(filter_size,
kernel,
padding='same',
kernel_initializer='he_normal')(x)
x = BatchNormalization()(x)
x = Add()([x, inputs])
return x
def reduction_A(input, k=192, l=224, m=256, n=384):
channel_axis = -1
r1 = MaxPooling2D((3, 3), strides=(2, 2))(input)
r2 = Conv2D(n, (3, 3), activation='relu', strides=(2, 2))(input)
r3 = Conv2D(k, (1, 1), activation='relu', padding='same')(input)
r3 = Conv2D(l, (3, 3), activation='relu', padding='same')(r3)
r3 = Conv2D(m, (3, 3), activation='relu', strides=(2, 2))(r3)
m = merge.concatenate([r1, r2, r3], axis=channel_axis)
m = BatchNormalization(axis=channel_axis)(m)
m = Activation('relu')(m)
return m
def _res_func(x):
identity = Cropping2D(cropping=((2, 2), (2, 2)))(x)
a = Conv2D(nb_filter, (nb_row, nb_col),
strides=stride,
padding='valid')(x)
a = BatchNormalization()(a)
#a = LeakyReLU(0.2)(a)
a = Activation("relu")(a)
a = Conv2D(nb_filter, (nb_row, nb_col),
strides=stride,
padding='valid')(a)
y = BatchNormalization()(a)
return add([identity, y])
def LeNet_model():
model = Sequential()
model.add(Conv2D(30, (5, 5), input_shape=(32, 32, 1), activation='relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Conv2D(15, (3, 3), activation='relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Flatten())
model.add(Dense(500, activation='relu'))
model.add(Dropout(0.5))
model.add(Dense(num_classes, activation='softmax'))
# Compile model
model.compile(optimizer = 'adam', loss='categorical_crossentropy', metrics=['accuracy'])
return model
def normalization(inp, norm="none", group="16"):
""" GAN Normalization """
if norm == "layernorm":
var_x = GroupNormalization(group=group)(inp)
elif norm == "batchnorm":
var_x = BatchNormalization()(inp)
elif norm == "groupnorm":
var_x = GroupNormalization(group=16)(inp)
elif norm == "instancenorm":
var_x = InstanceNormalization()(inp)
elif norm == "hybrid":
if group % 2 == 1:
raise ValueError(
"Output channels must be an even number for hybrid norm, "
"received {}.".format(group))
filt = group
var_x_0 = Lambda(lambda var_x: var_x[..., :filt // 2])(var_x)
var_x_1 = Lambda(lambda var_x: var_x[..., filt // 2:])(var_x)
var_x_0 = Conv2D(filt // 2,
kernel_size=1,
kernel_regularizer=regularizers.l2(GAN22_REGULARIZER),
kernel_initializer=GAN22_CONV_INIT)(var_x_0)
var_x_1 = InstanceNormalization()(var_x_1)
var_x = concatenate([var_x_0, var_x_1], axis=-1)
else:
var_x = inp
return var_x
def block(out,
nkernels,
down=True,
bn=True,
dropout=False,
leaky=True,
normalization=InstanceNormalization):
if leaky:
out = LeakyReLU(0.2)(out)
else:
out = Activation('relu')(out)
if down:
out = ZeroPadding2D((1, 1))(out)
out = Conv2D(nkernels,
kernel_size=(4, 4),
strides=(2, 2),
use_bias=False)(out)
else:
out = Conv2DTranspose(nkernels,
kernel_size=(4, 4),
strides=(2, 2),
use_bias=False)(out)
out = Cropping2D((1, 1))(out)
if bn:
out = normalization(axis=-1)(out)
if dropout:
out = Dropout(0.5)(out)
return out
def prepare_simple_model(input_tensor, loss_name, target):
axis = 1 if K.image_data_format() == 'channels_first' else -1
loss = None
num_channels = None
activation = None
if loss_name == 'sparse_categorical_crossentropy':
loss = lambda y_true, y_pred: K.sparse_categorical_crossentropy( # pylint: disable=g-long-lambda
y_true, y_pred, axis=axis)
num_channels = np.amax(target) + 1
activation = 'softmax'
elif loss_name == 'categorical_crossentropy':
loss = lambda y_true, y_pred: K.categorical_crossentropy( # pylint: disable=g-long-lambda
y_true, y_pred, axis=axis)
num_channels = target.shape[axis]
activation = 'softmax'
elif loss_name == 'binary_crossentropy':
loss = lambda y_true, y_pred: K.binary_crossentropy(y_true, y_pred) # pylint: disable=unnecessary-lambda
num_channels = target.shape[axis]
activation = 'sigmoid'
predictions = Conv2D(num_channels,
1,
activation=activation,
kernel_initializer='ones',
bias_initializer='ones')(input_tensor)
simple_model = keras.models.Model(inputs=input_tensor,
outputs=predictions)
simple_model.compile(optimizer='rmsprop', loss=loss)
return simple_model
def _shortcut(input, residual, weight_decay=1e-4):
"""Adds a shortcut between input and residual block and merges them with "sum"
"""
# Expand channels of shortcut to match residual.
# Stride appropriately to match residual (width, height)
# Should be int if network architecture is correctly configured.
input_shape = input.get_shape().as_list()
residual_shape = residual.get_shape().as_list()
stride_width = int(
round(input_shape[ROW_AXIS] /
residual_shape[ROW_AXIS])) # Problem for variable input
stride_height = int(round(input_shape[COL_AXIS] /
residual_shape[COL_AXIS]))
equal_channels = input_shape[CHANNEL_AXIS] == residual_shape[CHANNEL_AXIS]
shortcut = input
# 1 X 1 conv if shape is different. Else identity.
if stride_width > 1 or stride_height > 1 or not equal_channels:
shortcut = Conv2D(filters=residual_shape[CHANNEL_AXIS],
kernel_size=(1, 1),
strides=(stride_width, stride_height),
padding="valid",
kernel_initializer="he_normal",
kernel_regularizer=l2(weight_decay))(input)
return add([shortcut, residual])
def d_layer(layer_input, filters, f_size=4, bn=True):
"""Discriminator layer"""
d = Conv2D(filters, kernel_size=f_size, strides=2, padding='same')(layer_input)
d = LeakyReLU(alpha=0.2)(d)
if bn:
d = BatchNormalization(momentum=0.8)(d)
return d
def initialize_model():
one_filter_keras_model = Sequential()
one_filter_keras_model.add(
Conv2D(filters=40,
kernel_size=(1, 11),
padding="same",
input_shape=(1, 1500, 5),
kernel_constraint=NonNeg()))
one_filter_keras_model.add(BatchNormalization(axis=-1))
one_filter_keras_model.add(Activation('relu'))
one_filter_keras_model.add(MaxPooling2D(pool_size=(1, 30)))
one_filter_keras_model.add(Flatten())
one_filter_keras_model.add(Dense(40))
one_filter_keras_model.add(BatchNormalization(axis=-1))
one_filter_keras_model.add(Activation('relu'))
one_filter_keras_model.add(Dropout(0.5))
one_filter_keras_model.add(Dense(1))
one_filter_keras_model.add(Activation("sigmoid"))
one_filter_keras_model.summary()
one_filter_keras_model.compile(optimizer='adam',
loss='binary_crossentropy',
metrics=[precision, recall, specificity])
return one_filter_keras_model
