def create_normal_wide_resnet(N=4, k=10):
"""
Create vanilla conv Wide ResNet (N=4, k=10)
"""
# input
input = layers.Input((32, 32, 3))
# 16 channels block
x = layers.Conv2D(16, 3, padding="same")(input)
x = layers.BatchNormalization()(x)
x = layers.Activation("relu")(x)
# 1st block
x = _create_normal_residual_block(x, 16 * k, N)
# The original wide resnet is stride=2 conv for downsampling,
# but replace them to average pooling because centers are shifted when octconv
# 2nd block
x = layers.AveragePooling2D(2)(x)
x = _create_normal_residual_block(x, 32 * k, N)
# 3rd block
x = layers.AveragePooling2D(2)(x)
x = _create_normal_residual_block(x, 64 * k, N)
# FC
x = layers.GlobalAveragePooling2D()(x)
x = layers.Dense(10, activation="softmax")(x)
model = Model(input, x)
return model
def make_lenet5():
model = Sequential()
#make the neural network
model.add(
layers.Conv2D(filters=6,
kernel_size=(5, 5),
strides=1,
activation=activations.tanh,
input_shape=(32, 32, 1)))
model.add(
layers.AveragePooling2D(pool_size=(2, 2),
strides=2,
input_shape=(28, 28, 1)))
model.add(
layers.Conv2D(filters=16,
kernel_size=(5, 5),
strides=1,
activation=activations.tanh,
input_shape=(14, 14, 1)))
model.add(
layers.AveragePooling2D(pool_size=(2, 2),
strides=2,
input_shape=(10, 10, 1)))
model.add(
layers.Conv2D(filters=120,
kernel_size=(5, 5),
strides=1,
activation=activations.tanh,
input_shape=(5, 5, 1)))
model.add(layers.Flatten())
model.add(layers.Dense(units=84, activation=activations.tanh))
model.add(layers.Dense(units=10, activation=activations.softmax))
return model
def create_octconv_wide_resnet_5(alpha, N=4, k=10):
"""
Create OctConv Wide ResNet(N=4, k=10)
"""
# Input
input = layers.Input((32, 32, 3))
# downsampling for lower
low = layers.AveragePooling2D(2)(input)
# 16 channels block
high, low = OctConv2D(filters=16, alpha=alpha)([input, low])
high = layers.BatchNormalization()(high)
high = layers.Activation("relu")(high)
low = layers.BatchNormalization()(low)
low = layers.Activation("relu")(low)
# 1st block
high, low = _create_octconv_residual_block([high, low], 16 * k, N, alpha)
# 2nd block
high = layers.AveragePooling2D(2)(high)
low = layers.AveragePooling2D(2)(low)
high, low = _create_octconv_residual_block([high, low], 32 * k, N, alpha)
# 3rd block
high = layers.AveragePooling2D(2)(high)
low = layers.AveragePooling2D(2)(low)
high, low = _create_octconv_residual_block([high, low], 64 * k, N - 1,
alpha)
# 3rd block Last
x = _create_octconv_last_residual_block([high, low], 64 * k, alpha)
# FC
x = layers.GlobalAveragePooling2D()(x)
x = layers.Dense(5, activation="softmax")(x)
model = Model(input, x)
return model
def build_paper_model():
layer_one_input = keras.Input(shape=(240, 320, 3))
lays = layers.Conv2D(96, (11, 11), strides=4,
activation='relu')(layer_one_input)
lays = layers.AveragePooling2D(pool_size=2)(lays)
lays = layers.Conv2D(256, (5, 5), activation='relu')(lays)
lays = layers.AveragePooling2D(pool_size=2)(lays)
lays = layers.Conv2D(384, (3, 3), activation='relu')(lays)
lays = layers.AveragePooling2D()(lays)
lays = layers.Conv2D(384, (3, 5), activation='relu')(lays)
lays = layers.AveragePooling2D()(lays)
lays = layers.Dense(256)(lays)
lays = layers.Dropout(0.2)(lays)
lays = layers.Dense(4800)(lays)
#lays2 = layers.Conv2D(63,(9,9),strides=2,activation='relu')(layer_one_input)
#lays2 = layers.AveragePooling2D(pool_size=2)(lays2)
#lays2 = layers.Concatenate()([lays,lays2])
#lays2 = layers.Conv2D(64,(5,5),strides=1,activation='relu')(lays2)
#lays2 = layers.Conv2D(64,(5,5),strides=1,activation='relu')(lays2)
lays = layers.Reshape(target_shape=(60, 80))(lays)
model = keras.models.Model(inputs=[layer_one_input], outputs=lays)
model.compile(optimizer=optimizer,
loss='mean_squared_logarithmic_error',
metrics=['accuracy', psnr])
return model
def _build_classifier(self, l_rate):
l_rate = self._knobs.get('l_rate')
model = models.Sequential()
model.add(
layers.Conv2D(filters=6,
kernel_size=(3, 3),
activation='relu',
input_shape=(32, 32, 1)))
model.add(layers.AveragePooling2D())
model.add(
layers.Conv2D(filters=16, kernel_size=(3, 3), activation='relu'))
model.add(layers.AveragePooling2D())
model.add(layers.Flatten())
model.add(layers.Dense(units=120, activation='relu'))
model.add(layers.Dense(units=84, activation='relu'))
model.add(layers.Dense(units=10, activation='softmax'))
adam = Adam(lr=l_rate,
beta_1=0.9,
beta_2=0.999,
epsilon=None,
decay=0.0,
amsgrad=False)
model.compile(loss=keras.losses.categorical_crossentropy,
optimizer=adam,
metrics=['accuracy'])
return model
def create_discriminator(self):
""" Model to distinguish real images from generated ones."""
discriminator = Sequential()
discriminator.add(L.InputLayer(self.IMG_SHAPE))
discriminator.add(
L.Conv2D(16, kernel_size=(7, 7), padding='same', activation='elu'))
discriminator.add(
L.Conv2D(16, kernel_size=(7, 7), padding='same', activation='elu'))
discriminator.add(L.AveragePooling2D(strides=2))
discriminator.add(
L.Conv2D(32, kernel_size=(5, 5), padding='same', activation='elu'))
discriminator.add(
L.Conv2D(32, kernel_size=(5, 5), padding='same', activation='elu'))
discriminator.add(L.AveragePooling2D(strides=2))
discriminator.add(
L.Conv2D(64, kernel_size=(3, 3), padding='same', activation='elu'))
discriminator.add(
L.Conv2D(64, kernel_size=(3, 3), padding='same', activation='elu'))
discriminator.add(L.AveragePooling2D(strides=2))
discriminator.add(L.Flatten())
discriminator.add(L.Dense(256, activation='tanh'))
discriminator.add(L.Dense(2, activation=tf.nn.log_softmax))
self.discriminator = discriminator
print('Discriminator created successfully.')
def LeNet5(n_classes):
model = keras.Sequential()
model.add(
layers.Conv2D(filters=6,
kernel_size=(3, 3),
input_shape=(28, 28, 1),
padding='same'))
model.add(layers.normalization.BatchNormalization())
model.add(layers.Activation('relu'))
model.add(layers.AveragePooling2D())
model.add(layers.Conv2D(filters=16, kernel_size=(3, 3), padding='valid'))
model.add(layers.normalization.BatchNormalization())
model.add(layers.Activation('relu'))
model.add(layers.AveragePooling2D())
model.add(layers.Flatten())
model.add(layers.Dense(units=120))
model.add(layers.normalization.BatchNormalization())
model.add(layers.Activation('relu'))
model.add(layers.Dense(units=84))
model.add(layers.normalization.BatchNormalization())
model.add(layers.Activation('relu'))
model.add(layers.Dense(units=n_classes, activation='softmax'))
#sgd = keras.optimizers.SGD(lr=0.1, nesterov=True)
model.compile(loss=keras.losses.categorical_crossentropy,
optimizer='sgd',
metrics=['accuracy'])
return model
def make_lenet5():
model = Sequential()
# Todo: implement LeNet-5 model
model.add(
layers.Conv2D(filters=6,
input_shape=(32, 32, 1),
kernel_size=(5, 5),
strides=1,
activation=activations.tanh))
model.add(
layers.AveragePooling2D(input_shape=(28, 28, 1),
pool_size=(2, 2),
strides=2))
model.add(
layers.Conv2D(filters=16,
input_shape=(14, 14, 1),
kernel_size=(5, 5),
strides=1,
activation=activations.tanh))
model.add(
layers.AveragePooling2D(input_shape=(10, 10, 1),
pool_size=(2, 2),
strides=2))
model.add(
layers.Conv2D(filters=120,
input_shape=(5, 5, 1),
kernel_size=(5, 5),
strides=1,
activation=activations.tanh))
model.add(layers.Flatten())
model.add(layers.Dense(units=84, activation=activations.tanh))
model.add(layers.Dense(units=10, activation=activations.softmax))
######################
return model
def LeNet5():
#Instantiate an empty model
model = Sequential()
# C1 Convolutional Layer
model.add(layers.Conv2D(6, kernel_size=(5, 5), strides=(1, 1), activation='tanh', input_shape=input_shape, padding="same"))
# S2 Pooling Layer
model.add(layers.AveragePooling2D(pool_size=(2, 2), strides=(1, 1), padding='valid'))
# C3 Convolutional Layer
model.add(layers.Conv2D(16, kernel_size=(5, 5), strides=(1, 1), activation='tanh', padding='valid'))
# S4 Pooling Layer
model.add(layers.AveragePooling2D(pool_size=(2, 2), strides=(2, 2), padding='valid'))
# C5 Fully Connected Convolutional Layer
model.add(layers.Conv2D(120, kernel_size=(5, 5), strides=(1, 1), activation='tanh', padding='valid'))
#Flatten the CNN output so that we can connect it with fully connected layers
model.add(layers.Flatten())
# FC6 Fully Connected Layer
model.add(layers.Dense(84, activation='tanh'))
#Output Layer with softmax activation
model.add(layers.Dense(classes, activation='softmax'))
# Compile the model
model.compile(loss=keras.losses.categorical_crossentropy, optimizer='SGD', metrics=["accuracy"])
return model
def M7():
model = models.Sequential()
#VGG16 like
model.add(
layers.Conv2D(64,
kernel_size=kernel_size_3,
input_shape=(230, 510, 1),
activation='relu'))
model.add(layers.AveragePooling2D(pool_size=pool_size_2))
model.add(layers.BatchNormalization())
model.add(layers.Conv2D(64, kernel_size=kernel_size_3, activation='relu'))
model.add(layers.AveragePooling2D(pool_size=pool_size_2))
model.add(layers.BatchNormalization())
model.add(layers.Conv2D(64, kernel_size=kernel_size_3, activation='relu'))
model.add(layers.AveragePooling2D(pool_size=pool_size_2))
model.add(layers.BatchNormalization())
model.add(layers.Conv2D(64, kernel_size=kernel_size_3, activation='relu'))
model.add(layers.AveragePooling2D(pool_size=pool_size_2))
model.add(layers.BatchNormalization())
model.add(layers.Conv2D(64, kernel_size=kernel_size_5, activation='relu'))
model.add(layers.MaxPooling2D(pool_size=pool_size_2))
model.add(layers.Dropout(0.4))
model.add(layers.Flatten())
model.add(layers.Dense(500, activation='relu'))
model.add(layers.Dropout(0.4))
model.add(layers.Dense(3, activation='softmax'))
return model
def gen_model(shape):
input = layers.Input(shape=(shape))
# First conv layer
c_1 = layers.Conv2D(48, (3, 8), padding='same')(input)
c_2 = layers.Conv2D(32, (3, 32), padding='same')(input)
c_3 = layers.Conv2D(16, (3, 64), padding='same')(input)
c_4 = layers.Conv2D(16, (3, 90), padding='same')(input)
conv_1 = layers.Concatenate()([c_1, c_2, c_3, c_4])
x = layers.BatchNormalization()(conv_1)
x = layers.ReLU()(x)
# x = layers.MaxPooling2D((5,5))(x)
x = layers.AveragePooling2D((5, 5))(x)
# Second conv layer
x = layers.Conv2D(224, 5)(x)
x = layers.BatchNormalization()(x)
x = layers.ReLU()(x)
# x = layers.MaxPooling2D((6,4))(x)
x = layers.AveragePooling2D((6, 4))(x)
# Output layer
x = layers.Flatten()(x)
# x = layers.Dropout(0.5)(x)
x = layers.Dense(64)(x)
x = layers.Dense(1, activation='sigmoid')(x)
model = models.Model(input, x)
return model
def M12():
model = models.Sequential()
#VGG16 like
model.add(
layers.Conv2D(64,
kernel_size=kernel_size_3,
input_shape=(160, 120, 1),
activation='relu'))
model.add(layers.AveragePooling2D(pool_size=pool_size_2))
model.add(layers.BatchNormalization())
model.add(layers.Conv2D(64, kernel_size=kernel_size_3, activation='relu'))
model.add(layers.AveragePooling2D(pool_size=pool_size_2))
model.add(layers.BatchNormalization())
model.add(layers.Conv2D(64, kernel_size=kernel_size_3, activation='relu'))
model.add(layers.AveragePooling2D(pool_size=pool_size_2))
model.add(layers.BatchNormalization())
model.add(layers.Conv2D(128, kernel_size=kernel_size_5, activation='relu'))
model.add(layers.MaxPooling2D(pool_size=pool_size_2))
model.add(layers.Flatten())
#model.add(layers.BatchNormalization())
model.add(layers.Dense(200, activation='relu'))
#model.add(layers.Dropout(0.5))
model.add(layers.Dense(1, activation='linear'))
return model
def thanh_net(input_shape, num_classes):
model = keras.Sequential()
model.add(layers.Conv2D(filters=6, kernel_size=(3, 3), activation='relu', input_shape=input_shape))
model.add(layers.AveragePooling2D())
#model.add(layers.BatchNormalization)
model.add(layers.Conv2D(filters=16, kernel_size=(3, 3), activation='relu'))
model.add(layers.AveragePooling2D())
#model.add(layers.BatchNormalization)
model.add(layers.Conv2D(filters=32, kernel_size=(3, 3), activation='relu'))
model.add(layers.AveragePooling2D())
# #
#model.add(layers.Conv2D(filters=64, kernel_size=(3, 3), activation='relu'))
#model.add(layers.AveragePooling2D())
# model.add(layers.Conv2D(filters=32, kernel_size=(3, 3), activation='relu'))
# model.add(layers.AveragePooling2D())
model.add(layers.Flatten())
#model.add(layers.Dropout(0.8))
model.add(layers.Dense(units=120, activation='relu'))
model.add(layers.Dropout(0.5))
model.add(layers.Dense(units=84, activation='relu'))
#model.add(layers.Dropout(0.5))
model.add(layers.Dense(units=num_classes, activation='softmax'))
return model
def create_discriminator_model():
model = Sequential()
model.add(L.InputLayer(input_shape = data_sample.IMG_SHAPE))
model.add(L.Conv2D(filters = 32, kernel_size = [3,3]))
model.add(L.AveragePooling2D(pool_size = [2,2]))
model.add(L.Activation(activation = 'elu'))
model.add(L.Conv2D(filters = 64, kernel_size = [3,3]))
model.add(L.AveragePooling2D(pool_size = [2,2]))
model.add(L.Activation(activation = 'elu'))
model.add(L.Flatten())
model.add(L.Dense(units = 256, activation = 'tanh'))
model.add(L.Dense(units = 2, activation = tf.nn.log_softmax))
return model
def decode_graph(input_tensor, skip_layers, use_bias=True, train_bn=True):
conv_name_base = "decode_graph"
with tf.name_scope(conv_name_base) as sc:
downsample_16 = KL.AveragePooling2D(pool_size=(16,16))(input_tensor)
downsample_32 = KL.AveragePooling2D(pool_size=(8,8))(input_tensor)
downsample_64 = KL.AveragePooling2D(pool_size=(4,4))(input_tensor)
downsample_128 = KL.AveragePooling2D(pool_size=(2,2))(input_tensor)
x = KL.Conv2D(128, (1,1), activation="relu",
name="decode_conv_1")(skip_layers.pop())
x = KL.Concatenate()([x, downsample_16])
x = KL.Conv2D(64, (1,1), activation="relu",
name="decode_combine_conv_1")(x)
x = res_block(x, 3, [64, 64, 64], "decode_res_1", use_bias, train_bn)
for index, downsample_item in enumerate([downsample_32, downsample_64,
downsample_128, input_tensor]):
x = KL.Concatenate()([KL.UpSampling2D(size=(2,2))(x),
downsample_item])
x = KL.Conv2D(129, (1,1), activation="relu",
name="decode_conv_"+str(index+2))(x)
x = KL.Concatenate()([x, skip_layers.pop()])
x = KL.Conv2D(64, (1,1), activation="relu",
name="decode_combine_conv_"+str(index+2))(x)
x = res_block(x, 3, [64, 64, 64], "decode_res_" + str(index+2),
use_bias, train_bn)
decode_output = KL.Conv2D(1, (1,1), name="decode_result")(x)
output_mask = KL.Activation("sigmoid",
name="prob_output")(decode_output)
return decode_output, output_mask
def create_complex_model(param: Param) -> keras.Model:
inputs = keras.Input((28, 28, 1))
x = inputs
if param is not None:
x = layers.GaussianNoise(param.noise_stddev)(x)
x_re = x
x_im = layers.Lambda(lambda z: K.zeros((1, 28, 28, 1)))([])
for i in range(len(param.conv_filters)):
x_re, x_im = complexize_kernel(layers.Conv2D,
param.conv_filters[i],
kernel_size=param.kernel_sizes[i],
strides=param.strides[i],
padding='same',
activation=layers.Activation("tanh"))(
x_re, x_im)
x_re = layers.BatchNormalization(axis=-1)(x_re)
x_im = layers.BatchNormalization(axis=-1)(x_im)
if param.pool_sizes[i] is not None:
pool_size = param.pool_sizes[i]
pool_strides = param.pool_strides[i]
x_re = layers.AveragePooling2D(pool_size=pool_size,
strides=pool_strides)(x_re)
x_im = layers.AveragePooling2D(pool_size=pool_size,
strides=pool_strides)(x_im)
if param.conv_dropout_rates[i] is not None:
dropout_rate = param.conv_dropout_rates[i]
x_re = layers.Dropout(dropout_rate)(x_re)
x_im = layers.Dropout(dropout_rate)(x_im)
x_re = layers.Flatten()(x_re)
x_im = layers.Flatten()(x_im)
for units, dropout_rate in zip(param.dense_units,
param.dense_dropout_rates):
x_re, x_im = complexize_kernel(layers.Dense,
units,
activation=layers.Activation("tanh"))(
x_re, x_im)
if dropout_rate is not None:
x_re = layers.Dropout(dropout_rate)(x_re)
x_im = layers.Dropout(dropout_rate)(x_im)
# x = layers.Lambda(lambda d: K.sqrt(K.square(d[0]) + K.square(d[1])))([x_re, x_im])
if param.l2_constrained_scale:
x = layers.Lambda(lambda z: K.l2_normalize(z, axis=1) * param.
l2_constrained_scale)(x_re)
outputs = layers.Dense(10,
kernel_constraint=keras.constraints.UnitNorm(),
use_bias=False)(x)
else:
outputs = layers.Dense(10)(x_re)
model = keras.Model(inputs=inputs, outputs=outputs)
if param.center_loss_margin:
loss = CenterLoss(param.center_loss_margin)
else:
loss = tf.losses.softmax_cross_entropy
model.compile(loss=loss, optimizer='adam', metrics=['accuracy'])
return model
def build_default_model(self): K.set_learning_phase(True) inputs = keras.layers.Input( shape = self.data.size_input_image, name = "input" ) x = layer.Conv2D(32, kernel_size = (6,6), activation = "relu", padding = "same")(inputs) x = layer.AveragePooling2D( pool_size = (2,2), padding = "same" )(x) x = layer.Conv2D(64, kernel_size = (6,6), activation = "relu", padding = "same")(x) x = layer.AveragePooling2D( pool_size = (2,2), padding = "same" )(x) x = layer.Conv2D(128, kernel_size = (6,6), activation = "relu", padding = "same")(x) x = layer.AveragePooling2D( pool_size = (2,2), padding = "same" )(x) x = layer.Conv2D(256, kernel_size = (6,6), activation = "relu", padding = "same")(x) x = layer.AveragePooling2D( pool_size = (2,2), padding = "same" )(x) x = layer.Flatten()(x) x = layer.Dense(128, activation = "relu")(x) x = layer.Dropout(0.5)(x) x = layer.Dense(128, activation = "relu")(x) x = layer.Dropout(0.5)(x) outputs = layer.Dense(self.data.number_jet_categories, activation = "softmax")(x) pre_net = models.Model(input = [inputs], outputs = [outputs]) pre_net.summary() # main_net main_input = keras.layers.Input( shape = (self.data.n_input_neurons, ), name = "main_input") y = layer.Concatenate()([main_input, pre_net.output]) y = layer.Dense(100, activation="relu")(y) y = layer.Dropout(0.5)(y) y = layer.Dense(100, activation = "relu")(y) y = layer.Dropout(0.5)(y) y = layer.Dense(self.data.n_output_neurons, activation = "softmax")(y) main_net = models.Model(input = [inputs, main_input], outputs = [y]) main_net.summary() return pre_net, main_net
def sMGN(inputs,
_eval,
training=None,
return_all=True,
return_mgn=False,
l2_norm=True):
reg[0] = l1l2_reg
b2 = basicUnit(inputs, name='my_bu2', training=training)
shape = b2._keras_shape[-3:-1]
b2_g_max = KL.MaxPooling2D((shape[0], shape[1]))(b2)
b2_g_ave = KL.AveragePooling2D((shape[0], shape[1]))(b2)
b2_g = KL.Concatenate(axis=-1)([b2_g_max, b2_g_ave])
b2_s_max = KL.MaxPooling2D((shape[0] // 2, shape[1]),
strides=(shape[0] // 2, shape[1]),
padding='valid')(b2)
b2_s_ave = KL.AveragePooling2D((shape[0] // 2, shape[1]),
strides=(shape[0] // 2, shape[1]),
padding='valid')(b2)
b2_s = KL.Concatenate(axis=-1)([b2_s_max, b2_s_ave])
b3_s_max = KL.MaxPooling2D((shape[0] // 3, shape[1]),
strides=(shape[0] // 3, shape[1]),
padding='valid')(b2)
b3_s_ave = KL.AveragePooling2D((shape[0] // 3, shape[1]),
strides=(shape[0] // 3, shape[1]),
padding='valid')(b2)
b3_s = KL.Concatenate(axis=-1)([b3_s_max, b3_s_ave])
b2_s1, b2_s2 = KL.Lambda(lambda x: [x[:, 0:1, :, :], x[:, 1:2, :, :]])(
b2_s)
b3_s1, b3_s2, b3_s3 = KL.Lambda(
lambda x: [x[:, 0:1, :, :], x[:, 1:2, :, :], x[:, 2:3, :, :]])(b3_s)
reg[1] = None
if return_all:
b_all = [
DarknetConv2D_BN_Linear(256,
1,
strides=(2, 2),
name='my_dlt' + str(i),
training=training)(x)
for i, x in enumerate([b2_g, b2_s1, b2_s2, b3_s1, b3_s2, b3_s3])
]
if return_mgn:
return KL.Lambda(lambda x: tf.nn.l2_normalize(
tf.concat(x, axis=-1), dim=-1))(b_all)
b_all = KL.Lambda(lambda x: x, name='l2_norm')(b_all)
b_all = KL.Lambda(lambda x: [tf.nn.l2_normalize(f, dim=-1) for f in x],
name='l2_norm')(b_all) if _eval else b_all
return KL.Lambda(lambda x: tf.concat(x, axis=-1), )(b_all)
else:
bg = DarknetConv2D_BN_Linear(256,
1,
strides=(2, 2),
name='my_dlt' + str(0),
training=training)(b2_g)
return KL.Lambda(lambda x: tf.nn.l2_normalize(x, dim=-1))(
bg) if _eval else bg
def simple_CNN(input_shape, num_classes):
model = models.Sequential()
model.add(
layers.Convolution2D(filters=16,
kernel_size=(7, 7),
padding='same',
name='image_array',
input_shape=input_shape))
model.add(layers.BatchNormalization())
model.add(
layers.Convolution2D(filters=16, kernel_size=(7, 7), padding='same'))
model.add(layers.BatchNormalization())
model.add(layers.Activation('relu'))
model.add(layers.AveragePooling2D(pool_size=(2, 2), padding='same'))
model.add(layers.Dropout(.5))
model.add(
layers.Convolution2D(filters=32, kernel_size=(5, 5), padding='same'))
model.add(layers.BatchNormalization())
model.add(
layers.Convolution2D(filters=32, kernel_size=(5, 5), padding='same'))
model.add(layers.BatchNormalization())
model.add(layers.Activation('relu'))
model.add(layers.AveragePooling2D(pool_size=(2, 2), padding='same'))
model.add(layers.Dropout(.5))
model.add(
layers.Convolution2D(filters=64, kernel_size=(3, 3), padding='same'))
model.add(layers.BatchNormalization())
model.add(
layers.Convolution2D(filters=64, kernel_size=(3, 3), padding='same'))
model.add(layers.BatchNormalization())
model.add(layers.Activation('relu'))
model.add(layers.AveragePooling2D(pool_size=(2, 2), padding='same'))
model.add(layers.Dropout(.5))
model.add(
layers.Convolution2D(filters=128, kernel_size=(3, 3), padding='same'))
model.add(layers.BatchNormalization())
model.add(
layers.Convolution2D(filters=128, kernel_size=(3, 3), padding='same'))
model.add(layers.BatchNormalization())
model.add(layers.Activation('relu'))
model.add(layers.AveragePooling2D(pool_size=(2, 2), padding='same'))
model.add(layers.Dropout(.5))
model.add(
layers.Convolution2D(filters=256, kernel_size=(3, 3), padding='same'))
model.add(layers.BatchNormalization())
model.add(
layers.Convolution2D(filters=num_classes,
kernel_size=(3, 3),
padding='same'))
model.add(layers.GlobalAveragePooling2D())
model.add(layers.Activation('softmax', name='predictions'))
return model
def _pooling_function(self, inputs, pool_size, strides, padding,
data_format):
input_real, input_imag = complex_to_real_imag(inputs)
real_outputs = KL.AveragePooling2D(pool_size, strides,
padding)(input_real)
imag_outputs = KL.AveragePooling2D(pool_size, strides,
padding)(input_imag)
outputs = real_imag_to_complex(real_outputs, imag_outputs)
return outputs
def Discriminator(self, input_shape):
# Assuming model is not recurrent
model = Sequential()
# Architecture Based on EEG Classification Model at https://arxiv.org/pdf/1703.05051.pdf
model.add(layers.Conv2D(25, kernel_size=(1,11), strides=(1,1),
padding='same', input_shape=input_shape,
kernel_initializer='he_normal'))
#kernel_regularizer=regularizers.l2(.001)))
model.add(layers.Conv2D(25, kernel_size=(22,1), strides=(1,1),
padding='valid',
kernel_initializer='he_normal'))
#kernel_regularizer=regularizers.l2(.001)))
model.add(layers.LeakyReLU(alpha=0.2))
model.add(layers.AveragePooling2D(pool_size=(1,3)))
model.add(layers.Dropout(rate=0.2))
model.add(layers.Conv2D(50, kernel_size=(1,11),
padding='same',
kernel_initializer='he_normal'))
#kernel_regularizer=regularizers.l2(.001)))
model.add(layers.LeakyReLU(alpha=0.2))
model.add(layers.AveragePooling2D(pool_size=(1,3)))
model.add(layers.Dropout(rate=0.2))
model.add(layers.Conv2D(100, kernel_size=(1,11), strides=(1,1),
padding='same',
kernel_initializer='he_normal'))
#kernel_regularizer=regularizers.l2(.001)))
model.add(layers.LeakyReLU(alpha=0.2))
model.add(layers.AveragePooling2D(pool_size=(1,3)))
model.add(layers.Dropout(rate=0.2))
model.add(layers.Conv2D(200, kernel_size=(1,11), strides=(1,1),
padding='same',
kernel_initializer='he_normal'))
#kernel_regularizer=regularizers.l2(.001)))
model.add(layers.LeakyReLU(alpha=0.2))
model.add(layers.AveragePooling2D(pool_size=(1,3)))
model.add(layers.Dropout(rate=0.2))
model.add(layers.Flatten())
model.add(layers.Dense(1, activation='sigmoid'))
#model.summary()
eeg = layers.Input(shape=input_shape)
validity = model(eeg)
fixed = Container(eeg, validity)
return Model(eeg, validity), fixed
def __init__(self, input_shape = (112,112,3), num_clases=2):
self.__lenet = keras.Sequential()
self.__lenet.add(layers.Conv2D(filters=6, kernel_size=(3, 3), activation='relu', input_shape = input_shape))
self.__lenet.add(layers.AveragePooling2D())
self.__lenet.add(layers.Conv2D(filters=16, kernel_size=(3, 3), activation='relu'))
self.__lenet.add(layers.AveragePooling2D())
self.__lenet.add(layers.Flatten())
self.__lenet.add(layers.Dense(units=120, activation='relu'))
self.__lenet.add(layers.Dense(units=84, activation='relu'))
self.__lenet.add(layers.Dense(units=num_clases, activation = 'sigmoid'))
def LeNet():
network = models.Sequential
network.add(layers.Conv2D(filters=6,kernel_size=(3,3),activation='relu',input_shape=(28,28,1)))
network.add(layers.AveragePooling2D((2,2)))
network.add(layers.Conv2D(filters=16,kernel_size=(3,3),activation='relu'))
network.add(layers.AveragePooling2D((2,2)))
network.add(layers.Conv2D(filters=120,kernel_size=(3,3),activation='relu'))
network.add(layers.Flatten())
network.add(layers.Dense(84,activation='relu'))
network.add(layers.Dense(10,activation='softmax'))
return network
def create_models():
input = layers.Input((28, 28, 1))
x = conv_bn_relu(input, 32)
x = layers.AveragePooling2D(2)(x)
x = conv_bn_relu(x, 64)
x = layers.AveragePooling2D(2)(x)
x = conv_bn_relu(x, 128)
x = layers.GlobalAveragePooling2D()(x)
x = layers.Dense(10, activation="softmax")(x)
return Model(input, x)
def create_models():
input = layers.Input((28,28,1))
x = conv_bn_relu(input, 32)
x = layers.AveragePooling2D(2)(x)
x = conv_bn_relu(x, 64)
x = layers.AveragePooling2D(2)(x)
x = conv_bn_relu(x, 128)
x = layers.GlobalAveragePooling2D()(x)
x = layers.BatchNormalization()(x)
x = ClusteringAffinity(10, 1, 10.0)(x)
return Model(input, x)
def Generator(self, input_shape):
# f.close()
# Assuming input is 21x729x1
input1 = Input(shape=(input_shape))
c,t,d = input_shape
h = layers.Conv2D(25, kernel_size=(1,11), strides=(1,1),
padding='same', input_shape=input_shape,
kernel_initializer='he_normal',
kernel_regularizer=regularizers.l2(.001))(input1)
h = layers.Conv2D(25, kernel_size=(21,1), strides=(1,1),
padding='valid',
kernel_initializer='he_normal',
kernel_regularizer=regularizers.l2(.001))(h)
h = layers.LeakyReLU(alpha=0.2)(h)
h = layers.AveragePooling2D(pool_size=(1,3))(h)
h = layers.Conv2D(50, kernel_size=(1,11),
padding='same',
kernel_initializer='he_normal',
kernel_regularizer=regularizers.l2(.001))(h)
h = layers.LeakyReLU(alpha=0.2)(h)
h = layers.AveragePooling2D(pool_size=(1,3))(h)
h = layers.Conv2D(100, kernel_size=(1,11), strides=(1,1),
padding='same',
kernel_initializer='he_normal',
kernel_regularizer=regularizers.l2(.001))(h)
h = layers.LeakyReLU(alpha=0.2)(h)
h = layers.AveragePooling2D(pool_size=(1,3))(h)
h = layers.Conv2D(200, kernel_size=(1,11), strides=(1,1),
padding='same',
kernel_initializer='he_normal',
kernel_regularizer=regularizers.l2(.001))(h)
h = layers.LeakyReLU(alpha=0.2)(h)
h = layers.AveragePooling2D(pool_size=(1,3))(h)
h = layers.Flatten()(h)
h = layers.Dense(729, activation='tanh')(h)
gen_output = layers.Lambda(EEG_Concatenate,
output_shape=(c+1, t, d))([input1, h])
model = Model(inputs=input1, outputs=gen_output)
#model.summary()
return model
def __init__(self, input_shape, num_classes):
super().__init__()
self.add(layers.Conv2D(6, kernel_size=(5, 5), strides=(1, 1), activation='tanh', input_shape=input_shape, padding="same"))
self.add(layers.AveragePooling2D(pool_size=(2, 2), strides=(1, 1), padding='valid'))
self.add(layers.Conv2D(16, kernel_size=(5, 5), strides=(1, 1), activation='tanh', padding='valid'))
self.add(layers.AveragePooling2D(pool_size=(2, 2), strides=(2, 2), padding='valid'))
self.add(layers.Conv2D(120, kernel_size=(5, 5), strides=(1, 1), activation='tanh', padding='valid'))
self.add(layers.Flatten())
self.add(layers.Dense(84, activation='tanh'))
self.add(layers.Dense(num_classes, activation='softmax'))
self.compile(loss='categorical_crossentropy', metrics=['accuracy'], optimizer="sgd")
def create_models():
input = layers.Input((28, 28, 1))
x = conv_bn_relu(input, 32)
x = layers.AveragePooling2D(2)(x)
x = conv_bn_relu(x, 64)
x = layers.AveragePooling2D(2)(x)
x = conv_bn_relu(x, 128)
x = layers.GlobalAveragePooling2D()(x)
x = layers.Dense(2, name="latent_features",
kernel_initializer="he_normal")(x)
x = layers.BatchNormalization()(x)
x = ClusteringAffinity(10, 1, 5.0)(x)
return Model(input, x)
def lenet_model(): adam = Adam(lr=0.00001) model = Sequential() model.add(layers.Conv2D(6,(5,5), activation = 'relu', input_shape = (224,224,3), name = 'conv1')) model.add(layers.AveragePooling2D((2, 2), name = 'avgpool1')) model.add(layers.Conv2D(16,(5,5), activation = 'relu', name = 'conv2')) model.add(layers.AveragePooling2D((2, 2), name = 'avgpool2')) model.add(layers.Flatten(name = 'flatten')) model.add(layers.Dense(120, activation = 'relu', name = 'dense1')) model.add(layers.Dense(84, name = 'dense2')) #SOFTMAX DOESNT TRAIN SOMEHOW, SO STICK WITH SIGMOID model.add(layers.Dense(1, activation = 'sigmoid', name = 'dense3')) # Compile model model.compile(loss='binary_crossentropy', optimizer=adam, metrics=['accuracy']) return model
def sequential2(wd_rate=None):
reg = keras.regularizers.l2(wd_rate)
inputs = kl.Input(shape=[200, 200, 3])
x = kl.Conv2D(filters=20,
kernel_size=[5, 5],
use_bias=True,
activation='relu',
kernel_regularizer=reg)(inputs)
x = kl.Conv2D(filters=20,
kernel_size=[5, 5],
use_bias=True,
activation='relu',
kernel_regularizer=reg)(x)
x = kl.AveragePooling2D(pool_size=[2, 2])(x)
x = kl.Conv2D(filters=50,
kernel_size=[5, 5],
use_bias=True,
activation='relu',
kernel_regularizer=reg)(x)
x = kl.AveragePooling2D(pool_size=[2, 2])(x)
x = kl.Conv2D(filters=50,
kernel_size=[5, 5],
use_bias=True,
activation='relu',
kernel_regularizer=reg)(x)
x = kl.AveragePooling2D(pool_size=[2, 2])(x)
x = kl.Conv2D(filters=50,
kernel_size=[5, 5],
use_bias=True,
activation='relu',
kernel_regularizer=reg)(x)
x = kl.AveragePooling2D(pool_size=[2, 2])(x)
x = kl.Conv2D(filters=35,
kernel_size=[5, 5],
use_bias=True,
activation='relu',
kernel_regularizer=reg)(x)
x = kl.Flatten()(x)
x = kl.Dense(units=60,
activation='relu',
use_bias=True,
kernel_regularizer=reg)(x)
x = kl.Dropout(rate=0.20)(x)
x = kl.Dense(units=29,
activation='softmax',
use_bias=True,
kernel_regularizer=reg)(x)
return keras.Model(inputs=(inputs, ), outputs=(x, ))
