def build_model_CNN(self):
''' CNN '''
model = Sequential()
embedding_layer = Embedding(self.vocab_length,
300,
weights=[self.embedding_matrix],
input_length=self.length_long_sentence,
trainable=False)
model.add(embedding_layer)
model.add(
Conv1D(filters=150,
kernel_regularizer=l2(0.01),
kernel_size=5,
strides=1,
padding='valid'))
model.add(MaxPooling1D(2, padding='valid'))
model.add(
Conv1D(filters=150,
kernel_regularizer=l2(0.01),
kernel_size=5,
strides=1,
padding='valid'))
model.add(MaxPooling1D(2, padding='valid'))
model.add(Flatten())
model.add(Dense(80, kernel_regularizer=l2(0.01), activation='relu'))
model.add(Dense(40, kernel_regularizer=l2(0.01), activation='relu'))
model.add(Dense(20, kernel_regularizer=l2(0.01), activation='relu'))
model.add(Dense(2, activation='sigmoid'))
model.compile(loss='binary_crossentropy',
optimizer=RMSprop(lr=0.001),
metrics=['accuracy'])
model.summary()
def DenseNetLayer(x, b, f, n=1):
"""
Implementation of a DenseNetLayer
:param x: input
:param b: number of elementary blocks in the layer
:param f: features generated at every block
:param n: unique identifier of the DenseNetLayer
:param training: passed to the batch normalization layers
:return:
"""
with tf.name_scope(f"denseNet_{n}"):
for _ in range(b):
y = BatchNormalization()(x)
y = Conv1D(filters=4 * f,
kernel_size=1,
padding='same',
data_format='channels_last')(y)
y = Activation('relu')(y)
y = BatchNormalization()(y)
y = Conv1D(filters=f,
kernel_size=8,
padding='same',
data_format='channels_last')(y)
y = Activation('relu')(y)
x = Concatenate()([x, y])
return x
def build(self):
n_steps, n_length = 4, 32
self.train_X = self.train_X.reshape(
(self.train_X.shape[0], n_steps, n_length, self.n_features)) # self.n_features = 6
self.test_X = self.test_X.reshape(
(self.test_X.shape[0], n_steps, n_length, self.n_features))
model = Sequential()
model.add(TimeDistributed(Conv1D(filters=64, kernel_size=3,
activation='relu'), input_shape=(None, n_length, self.n_features)))
model.add(TimeDistributed(
Conv1D(filters=16, kernel_size=3, activation='relu')))
model.add(TimeDistributed(Dropout(0.5)))
model.add(TimeDistributed(MaxPooling1D(pool_size=2)))
model.add(TimeDistributed(Flatten()))
model.add(LSTM(100))
model.add(Dropout(0.5))
model.add(Dense(100, activation='relu'))
model.add(Dense(self.n_outputs, activation='softmax'))
model.compile(loss='categorical_crossentropy',
optimizer='adam', metrics=['accuracy'])
# print(model.summary())
# input()
super().build(model)
def build_astronet2(len_local, len_global, n_features, drop1, lr):
inputA = Input(shape=(len_local, n_features))
inputB = Input(shape=(len_global, n_features))
loc = Conv1D(16, 5, activation='relu', padding='same')(inputA)
loc = Conv1D(16, 5, activation='relu', padding='same')(loc)
loc = MaxPooling1D(5, strides=2)(loc)
loc = Conv1D(32, 5, activation='relu', padding='same')(loc)
loc = Conv1D(32, 5, activation='relu', padding='same')(loc)
loc = MaxPooling1D(5, strides=2)(loc)
loc = Flatten()(loc)
glob = Conv1D(16, 5, activation='relu', padding='same')(inputB)
glob = Conv1D(16, 5, activation='relu', padding='same')(glob)
glob = MaxPooling1D(5, strides=2)(glob)
glob = Conv1D(32, 5, activation='relu', padding='same')(glob)
glob = Conv1D(32, 5, activation='relu', padding='same')(glob)
glob = MaxPooling1D(5, strides=2)(glob)
glob = Conv1D(64, 5, activation='relu', padding='same')(glob)
glob = Conv1D(64, 5, activation='relu', padding='same')(glob)
glob = MaxPooling1D(5, strides=2)(glob)
glob = Flatten()(glob)
joined = concatenate([loc, glob])
joined = Dense(64, activation='relu')(joined)
joined = Dropout(drop1)(joined)
joined = Dense(32, activation='relu')(joined)
out = Dense(1, activation='sigmoid')(joined)
model = Model(inputs=[inputA, inputB], outputs=out)
opt = Adam(lr=lr, epsilon=(10**(-8)))
model.compile(optimizer=opt, loss='binary_crossentropy', metrics=metrics)
return model
def build_model() -> Model:
"""
This is the code for the "NYU" model from "Character Level Based Detection of DGA Domain Names"
(http://faculty.washington.edu/mdecock/papers/byu2018a.pdf)
which is itself adapted from X. Zhang, J. Zhao, and Y. LeCun, “Character-level convolutional networks for text
classification,” in Advances in Neural Information Processing Systems, vol. 28, 2015, pp. 649–657.
"""
# a constant here representing the maximum expected length of a domain.
max_length = 75
main_input = Input(shape=(max_length,), dtype="int32", name="main_input")
embedding = Embedding(input_dim=128, output_dim=128, input_length=max_length)(main_input)
conv1 = Conv1D(filters=128, kernel_size=3, padding="same", strides=1)(embedding)
thresh1 = ThresholdedReLU(1e-6)(conv1)
max_pool1 = MaxPooling1D(pool_size=2, padding="same")(thresh1)
conv2 = Conv1D(filters=128, kernel_size=2, padding="same", strides=1)(max_pool1)
thresh2 = ThresholdedReLU(1e-6)(conv2)
max_pool2 = MaxPooling1D(pool_size=2, padding="same")(thresh2)
flatten = Flatten()(max_pool2)
fc = Dense(64)(flatten)
thresh_fc = ThresholdedReLU(1e-6)(fc)
drop = Dropout(0.5)(thresh_fc)
output = Dense(1, activation="sigmoid")(drop)
model = Model(inputs=main_input, outputs=output)
precision = as_keras_metric(tf.metrics.precision)
recall = as_keras_metric(tf.metrics.recall)
model.compile(
loss="binary_crossentropy",
optimizer="adam",
metrics=["mae", "mean_squared_error", "acc", precision, recall],
)
return model
def _cnn(x_shape):
"""https://github.com/lykaust15/Deep_learning_examples/blob/master/
8.RBP_prediction_CNN/RBP_binding_site_prediction.ipynb"""
model = Sequential([
Conv1D(128, (10, ),
activation='relu',
input_shape=(x_shape[1], x_shape[2])),
Dropout(0.25),
MaxPooling1D(pool_size=(3, ), strides=(1, )),
Conv1D(128, (10, ), activation='relu', padding='same'),
Dropout(0.25),
MaxPooling1D(pool_size=(3, ), strides=(1, )),
Conv1D(256, (5, ), activation='relu', padding='same'),
Dropout(0.25),
GlobalAveragePooling1D(),
Dropout(0.25),
Dense(128, activation='relu'),
Dropout(0.5),
Dense(1, activation='sigmoid')
])
model.compile(loss='binary_crossentropy',
optimizer=Adadelta(),
metrics=['accuracy'])
return model
def build_cnn_lstm_attn(local_steps, global_steps, n_features, lr, loc_f1,
loc_k1, loc_p1, loc_drop1, glob_f1, glob_k1, glob_p1,
glob_f2, glob_k2, glob_p2, glob_drop1, n_neurons1,
n_neurons2, n_neurons3, n_neurons4, n_neurons5, drop1,
drop2, reg):
inputA = Input(shape=(local_steps, n_features))
inputB = Input(shape=(global_steps, n_features))
local = Conv1D(loc_f1, loc_k1, padding='same', activation='relu')(inputA)
local = Conv1D(loc_f1, loc_k1, padding='same', activation='relu')(local)
local = MaxPooling1D(loc_p1)(local)
local = LSTM(n_neurons1, dropout=loc_drop1,
kernel_regularizer=l2(reg))(local)
glob = Conv1D(glob_f1, glob_k1, padding='same', activation='relu')(inputB)
glob = Conv1D(glob_f1, glob_k1, padding='same', activation='relu')(glob)
glob = MaxPooling1D(glob_p1)(glob)
glob = Conv1D(glob_f2, glob_k2, padding='same', activation='relu')(glob)
glob = MaxPooling1D(glob_p2)(glob)
glob = LSTM(n_neurons2, dropout=glob_drop1,
kernel_regularizer=l2(reg))(glob)
joined = Attention()([local, glob])
joined = Dense(n_neurons3, activation='relu',
kernel_regularizer=None)(joined)
joined = Dropout(drop1)(joined)
joined = Dense(n_neurons4, activation='relu',
kernel_regularizer=None)(joined)
joined = Dropout(drop2)(joined)
joined = Dense(n_neurons5, activation='relu',
kernel_regularizer=None)(joined)
out = Dense(1, activation='sigmoid')(joined)
model = Model(inputs=[inputA, inputB], outputs=out)
opt = Adam(lr=lr)
model.compile(optimizer=opt, loss='binary_crossentropy', metrics=metrics)
return model
def identity_block_1d(input_tensor, kernel_size, filters, stage, block):
"""The identity block is the block that has no conv layer at shortcut.
# Arguments
input_tensor: input tensor
kernel_size: default 3, the kernel size of middle conv layer at main path
filters: list of integers, the filters of 3 conv layer at main path
stage: integer, current stage label, used for generating layer names
block: 'a','b'..., current block label, used for generating layer names
# Returns
Output tensor for the block.
"""
filters1, filters2, filters3 = filters
conv_name_base = 'res_1d' + str(stage) + block + '_branch'
bn_name_base = 'bn_1d' + str(stage) + block + '_branch'
x = Conv1D(filters1, (1), name=conv_name_base + '2a')(input_tensor)
x = BatchNormalization(name=bn_name_base + '2a')(x)
x = Activation('relu')(x)
x = Conv1D(filters2,
kernel_size,
padding='same',
name=conv_name_base + '2b')(x)
x = BatchNormalization(name=bn_name_base + '2b')(x)
x = Activation('relu')(x)
x = Conv1D(filters3, (1), name=conv_name_base + '2c')(x)
x = BatchNormalization(name=bn_name_base + '2c')(x)
x = layers.add([x, input_tensor])
x = Activation('relu')(x)
return x
def build_sep_cnn_lstm(n_steps,
n_features,
lr,
n_filters,
n_filters2,
k_size,
p_size,
n_neurons1,
n_neurons2,
n_neurons3,
drop1,
drop2,
reg='None'):
inp = Input(shape=(n_steps, n_features))
rnn = LSTM(n_neurons1, return_sequences=True, kernel_regularizer=reg)(inp)
rnn = LSTM(n_neurons2)(rnn)
rnn = Dropout(drop1)(rnn)
cnn = Conv1D(n_filters, k_size, padding='same', activation='relu')(inp)
cnn = MaxPooling1D(p_size)(cnn)
cnn = Conv1D(n_filters2,
k_size,
padding='same',
activation='relu',
kernel_regularizer=reg)(cnn)
cnn = MaxPooling1D(p_size)(cnn)
cnn = Flatten()(cnn)
cnn = Dropout(drop2)(cnn)
rnn = concatenate([rnn, cnn])
rnn = Dense(n_neurons3, activation='relu', kernel_regularizer=reg)(rnn)
out = Dense(1, activation='sigmoid')(rnn)
model = Model(inp, out)
opt = Adam(lr=lr)
model.compile(optimizer=opt, loss='binary_crossentropy', metrics=metrics)
return model
def cnn_trans(local_steps, global_steps, n_features, lr, loc_f1, loc_k1,
loc_p1, glob_f1, glob_k1, glob_p1, glob_f2, glob_k2, glob_p2,
n_neurons1, n_neurons2, n_neurons3, drop1, drop2, num_heads,
key_dim):
inputA = Input(shape=(local_steps, n_features))
inputB = Input(shape=(global_steps, n_features))
local = Conv1D(loc_f1, loc_k1, padding='same', activation='relu')(inputA)
local = Conv1D(loc_f1, loc_k1, padding='same', activation='relu')(local)
local = MaxPooling1D(loc_p1)(local)
glob = Conv1D(glob_f1, glob_k1, padding='same', activation='relu')(inputB)
glob = Conv1D(glob_f1, glob_k1, padding='same', activation='relu')(glob)
glob = MaxPooling1D(glob_p1)(glob)
glob = Conv1D(glob_f2, glob_k2, padding='same', activation='relu')(glob)
glob = MaxPooling1D(glob_p2)(glob)
joined = MultiHeadAttention(num_heads, key_dim,
kernel_regularizer='l2')(local, glob)
joined = Flatten()(joined)
joined = Dense(n_neurons1, activation='relu',
kernel_regularizer='l2')(joined)
joined = Dropout(drop1)(joined)
joined = Dense(n_neurons2, activation='relu',
kernel_regularizer=None)(joined)
joined = Dropout(drop2)(joined)
joined = Dense(n_neurons3, activation='relu',
kernel_regularizer=None)(joined)
out = Dense(1, activation='sigmoid')(joined)
model = Model(inputs=[inputA, inputB], outputs=out)
opt = Adam(lr=lr)
model.compile(optimizer=opt, loss='binary_crossentropy', metrics=metrics)
return model
def _cnn_maxpool_multifilter(self, name: str) -> Model:
"""https://richliao.github.io/supervised/classification/2016/11/26/textclassifier-convolutional/
"""
convs = []
filter_sizes = [3, 4, 5]
_inputs = Input((self.maxlen, ), name='input')
l_embed = Embedding(input_dim=self.input_dim,
output_dim=self.embed_dim,
input_length=self.maxlen,
name='embedding')(_inputs)
for fsz in filter_sizes:
l_conv = Conv1D(filters=self.conv_filters,
kernel_size=fsz,
activation='relu')(l_embed)
l_pool = MaxPool1D(self.conv_pool_size)(l_conv)
convs.append(l_pool)
l_merge = Concatenate(axis=1)(convs)
l_cov1 = Conv1D(filters=self.conv_filters,
kernel_size=self.conv_kernel_size,
activation='relu')(l_merge)
l_pool1 = MaxPool1D(pool_size=self.conv_pool_size)(l_cov1)
l_cov2 = Conv1D(filters=self.conv_filters,
kernel_size=self.conv_kernel_size,
activation='relu')(l_pool1)
l_pool2 = GlobalMaxPool1D()(l_cov2)
l_flat = Flatten()(l_pool2)
l_dense = Dense(self.units, activation='relu')(l_flat)
_preds = Dense(self.classes, activation='sigmoid', name='fc1')(l_dense)
return Model(inputs=_inputs, outputs=_preds, name=name)
def crnn_model(width=100,
n_vars=6,
n_classes=7,
conv_kernel_size=5,
conv_filters=3,
lstm_units=3):
input_shape = (width, n_vars)
model = Sequential()
model.add(
Conv1D(filters=conv_filters,
kernel_size=conv_kernel_size,
padding='valid',
activation='relu',
input_shape=input_shape))
model.add(
Conv1D(filters=conv_filters,
kernel_size=conv_kernel_size,
padding='valid',
activation='relu'))
model.add(LSTM(units=lstm_units, dropout=0.1, recurrent_dropout=0.1))
model.add(Dense(n_classes, activation="softmax"))
model.compile(loss='categorical_crossentropy',
optimizer='adam',
metrics=['accuracy'])
return model
def define_model():
input_shape = (99, 13)
output_shape = 35
activation = 'relu'
input_layer = keras.Input(shape=input_shape)
h = Conv1D(256, 5, activation=activation, padding='same')(input_layer)
h = BatchNormalization()(h)
h = Conv1D(256, 5, activation=activation, padding='same')(h)
#h = BatchNormalization()(h)
h = MaxPool1D(3)(h)
h = Conv1D(512, 5, activation=activation, padding='same')(h)
#h = BatchNormalization()(h)
h = Dropout(0.35)(h)
h = Conv1D(512, 5, activation=activation, padding='same')(h)
h = GlobalAveragePooling1D()(h)
h = Dropout(0.5)(h)
output_layer = Dense(35, activation='softmax')(h)
model = keras.Model(inputs=input_layer, outputs=output_layer)
return model
def get_locnet(locnet_inputs, output_shape):
# Define filters
c1 = 128
c2 = 64
c3 = 64
# CNN
inputs = locnet_inputs
x1 = Conv1D(c1, (8), padding='same')(inputs)
x1 = BatchNormalization()(x1)
x1 = Activation('relu')(x1)
x1 = MaxPool1D(2)(x1)
x1 = Conv1D(c2, (5), padding='same')(x1)
x1 = BatchNormalization()(x1)
x1 = Activation('relu')(x1)
x1 = MaxPool1D(2)(x1)
x1 = Conv1D(c3, (3), padding='same')(x1)
x1 = BatchNormalization()(x1)
x1 = Activation('relu')(x1)
x1 = MaxPool1D(2)(x1)
x1 = Flatten()(x1)
# Output Layer
locnet_outputs = Dense(output_shape, activation='tanh')(x1)
# Define model
locnet = Model(inputs=locnet_inputs,
outputs=locnet_outputs,
name="Localization Network")
return locnet
def evaluate_model(trainX, trainy, testX, testy):
global best_accuracy
verbose, epochs, batch_size = 0, 10, 32
# n_timesteps, n_features, n_outputs = trainX.shape[1], trainX.shape[2], trainy.shape[1]
model = Sequential()
# model.add(Conv1D(filters=64, kernel_size=3, activation='relu', input_shape=(n_timesteps,n_features))) (x_train.shape[1],1)
model.add(
Conv1D(filters=64,
kernel_size=3,
activation='relu',
input_shape=(trainX.shape[1], 1)))
model.add(Conv1D(filters=64, kernel_size=3, activation='relu'))
model.add(Dropout(0.5))
model.add(MaxPooling1D(pool_size=2))
model.add(Flatten())
model.add(Dense(100, activation='relu'))
model.add(Dense(trainy.shape[1], activation='softmax'))
model.compile(loss='categorical_crossentropy',
optimizer='adam',
metrics=['accuracy'])
# fit network
model.fit(trainX, trainy, epochs=epochs, batch_size=batch_size, verbose=1)
# evaluate model
_, accuracy = model.evaluate(testX,
testy,
batch_size=batch_size,
verbose=0)
if accuracy > best_accuracy:
best_accuracy = accuracy
model.save(BestModleFilePath)
return accuracy
def model_v2(top_layer_units):
model = Sequential()
model.add(
TimeDistributed(Conv1D(filters=16,
kernel_size=4,
padding='same',
activation=tf.nn.relu,
data_format='channels_last'),
input_shape=(NUM_MFCC, NUM_FRAMES, 1)))
model.add(
TimeDistributed(
Conv1D(filters=8,
kernel_size=2,
padding='same',
activation=tf.nn.relu)))
model.add(TimeDistributed(MaxPooling1D(pool_size=2)))
model.add(TimeDistributed(Flatten()))
model.add(LSTM(50, return_sequences=True))
model.add(Dropout(0.3))
model.add(Flatten())
model.add(Dense(units=512, activation=tf.nn.tanh))
model.add(Dense(units=256, activation=tf.nn.tanh))
model.add(
Dense(units=top_layer_units,
activation=tf.nn.softmax,
name='top_layer'))
return model
def encode_embedding_input(input_layer,
type='subject',
reduce_size=False,
reduce_size_n=32
):
conv1_size = CONV_SIZES[type][0]
if noise:
input_layer = GaussianNoise(stddev=.001)(input_layer)
if normalization:
input_layer = BatchNormalization()(input_layer)
if reduce_size:
input_layer = Dense(reduce_size_n, activation="sigmoid")(input_layer)
conv1 = Conv1D(conv1_size, (2,), activation=mish, padding='same')(input_layer)
pool1 = MaxPooling1D((2,), padding='same')(conv1)
if type in ['subject', 'object']:
return Flatten()(pool1)
conv2_size = CONV_SIZES[type][1]
conv2 = Conv1D(conv2_size, (2,), activation=mish, padding='same')(pool1)
pool2 = MaxPooling1D((2,), padding='same')(conv2)
return Flatten()(pool2)
def create_2_layer_CNN():
model = Sequential()
model.add(
Conv1D(nodes,
kernel_size=3,
strides=1,
activation='relu',
input_shape=input_shape))
model.add(BatchNormalization())
model.add(MaxPooling1D(pool_size=2))
model.add(Dropout(dropRate))
#
model.add(Conv1D(32, 3, activation='relu'))
model.add(BatchNormalization())
model.add(MaxPooling1D(pool_size=2))
model.add(Dropout(dropRate))
model.add(Flatten())
model.add(Dense(256, activation='relu'))
# model.add(BatchNormalization())
model.add(Dense(128, activation='relu'))
# model.add(BatchNormalization())
model.add(Dense(num_classes, activation='softmax'))
model.compile(loss=keras.losses.categorical_crossentropy,
optimizer=keras.optimizers.Adam(),
metrics=['accuracy'])
return model
def _cnn_maxpool(self, name: str) -> Model:
"""https://richliao.github.io/supervised/classification/2016/11/26/textclassifier-convolutional/
"""
return Sequential([
InputLayer(input_shape=(self.maxlen, ), name='input'),
Embedding(input_dim=self.input_dim,
output_dim=self.embed_dim,
input_length=self.maxlen,
name='embedding'),
Conv1D(filters=self.conv_filters,
kernel_size=self.conv_kernel_size,
activation='relu'),
MaxPool1D(pool_size=self.conv_pool_size),
Conv1D(filters=self.conv_filters,
kernel_size=self.conv_kernel_size,
activation='relu'),
MaxPool1D(pool_size=self.conv_pool_size),
Conv1D(filters=self.conv_filters,
kernel_size=self.conv_kernel_size,
activation='relu'),
GlobalMaxPool1D(),
Flatten(),
Dense(self.units, activation='relu'),
Dense(self.classes, activation='sigmoid', name='fc1'),
],
name=name)
def make_cnn_model(vocab_size=10000, embed_dim=8, input_seq_length=20):
"""
I am the builder function for the CNN Model.
:param vocab_size: size of the vocabulary of the embedding, should be size of vocab of the vectorizer
:param embed_dim: how many dimensions to use for the vector embedding
:param input_seq_length: how long the sequence of inputs will be
:return: Keras Model
"""
x = inp = Input(shape=(None, ), dtype="int64")
x = Embedding(
input_dim=vocab_size,
output_dim=embed_dim,
input_length=input_seq_length,
)(x)
x = Conv1D(filters=64, kernel_size=3, strides=2, activation="linear")(x)
x = BatchNormalization()(x)
x = LeakyReLU()(x)
x = Conv1D(filters=64, kernel_size=3, strides=2, activation="linear")(x)
x = BatchNormalization()(x)
x = LeakyReLU()(x)
x = Conv1D(filters=64, kernel_size=3, strides=2, activation="linear")(x)
x = BatchNormalization()(x)
x = LeakyReLU()(x)
x = GlobalMaxPooling1D()(x)
x = Dense(units=128, activation="linear")(x)
x = BatchNormalization()(x)
x = LeakyReLU()(x)
out = Dense(1, activation="sigmoid")(x)
return Model(inputs=[inp], outputs=[out], name="cnn_model")
def decode_embedding_input(latent, shape, name, large=False):
conv1_size = 128 if large else 64
latent = Reshape((1, INNER_SIZE))(latent)
conv1 = Conv1D(conv1_size, (1,), activation='mish', padding='same', name=name + '_conv1')(latent)
up1 = UpSampling1D(shape[0], name=name + '_up1')(conv1)
conv2 = Conv1D(shape[1], (6,), activation='mish', padding='same', name=name + '_conv2')(up1)
return conv2
def res_block(x_in, num_filters, momentum=0.8, training=False):
x = Conv1D(num_filters, kernel_size=3, padding='same')(x_in)
x = BatchNormalization(momentum=momentum)(x, training=training)
x = PReLU(shared_axes=[1, 2])(x)
x = Conv1D(num_filters, kernel_size=3, padding='same')(x)
x = BatchNormalization(momentum=momentum)(x, training=training)
x = Add()([x_in, x])
return x
def create_convolutional_decoder(encoder):
conv1 = Conv1D(filters=32, kernel_size=42, activation='relu', input_shape=(INPUT_LENGTH, 1))(input_shape)
conv1 = UpSampling1D(pool_size=10)(conv1)
conv1 = BatchNormalization()(conv1)
conv2 = Conv1D(filters=64, kernel_size=59, activation='relu')(conv1)
conv2 = MaxPooling1D(pool_size=10)(conv2)
conv2 = BatchNormalization()(conv2)
return conv2
def graph(self,
type='shallow',
filter_size=3,
filter_num=100,
num_filter_block=None,
dropout_rate=0):
def ConvBlock(model, filters, kernel_size=filter_size):
model.add(BatchNormalization())
model.add(
Conv1D(filters=filters,
kernel_size=kernel_size,
padding='same',
activation='relu'))
model.add(BatchNormalization())
model.add(
Conv1D(filters=filters,
kernel_size=kernel_size,
padding='same',
activation='relu'))
if type == 'shallow' or type == 'scnn':
self.model.add(
Conv1D(kernel_size=filter_size,
strides=1,
filters=filter_num,
padding='valid',
activation='relu'))
self.model.add(
MaxPooling1D(pool_size=self.data_sequence - filter_size,
strides=1,
padding='valid'))
self.model.add(Flatten())
self.model.add(Dropout(rate=dropout_rate))
self.model.add(Dense(self.num_labels, activation='softmax'))
elif type == 'deep' or type == 'dcnn':
self.model.add(
Conv1D(kernel_size=filter_size,
filters=filter_num,
padding='same',
activation='relu'))
cur_filter_num = filter_num
for _, num_blocks in enumerate(num_filter_block):
for i in range(num_blocks):
ConvBlock(model=self.model,
kernel_size=filter_size,
filters=cur_filter_num)
self.model.add(MaxPooling1D(pool_size=3, strides=2))
cur_filter_num *= 2
self.model.add(Flatten())
self.model.add(Dense(2048, activation='relu', name='Dense1'))
self.model.add(Dense(2048, activation='relu', name='Dense2'))
self.model.add(
Dense(self.num_labels, activation='softmax', name='Output'))
self.model.summary()
def __init__(self,
units,
input_size,
niter,
kbinmap,
args,
droprate=0.05,
regrate=1e-5):
super(RIMHybrid, self).__init__()
self.nc, self.bs = args.nc, args.bs
nc, bs = args.nc, args.bs
self.niter = niter
print("number of iterations : ", niter)
self.beta_1, self.beta_2 = 0.9, 0.999
self.lr = 0.1
self.eps = 1e-7
self.kbinmap = tf.constant(kbinmap)
self.kbinmapflat = tf.constant(kbinmap.flatten())
self.layers_in = [
Dense(units, activation='tanh', kernel_regularizer=l2reg(regrate))
for i in range(niter)
]
self.drop_in = [Dropout(rate=droprate) for i in range(niter)]
self.layers_out = [
Dense(2 * nc,
activation='linear',
kernel_regularizer=l2reg(regrate)) for i in range(niter)
]
self.drop_out = [Dropout(rate=droprate) for i in range(niter)]
self.conv_in = [
Conv1D(1, 1, activation='linear') for i in range(niter)
]
self.conv_out = [Conv1D(1, 1) for i in range(niter)]
self.conv_relu = [
Conv1D(1, 1, activation='relu') for i in range(niter)
]
self.layers1d = [[self.layers_in[i], self.layers_out[i], \
self.drop_in[i], self.drop_out[i],
self.conv_in[i], self.conv_out[i],
self.conv_relu[i]] for i in range(niter)]
cell_size = input_size
self.input_layer = Conv3D(input_size,
kernel_size=5,
trainable=True,
padding='SAME',
input_shape=(None, nc, nc, nc, 2),
activation='tanh')
self.cell = ConvLSTM3DCell(cell_size, kernel_size=5, padding='SAME')
self.output_layer = Conv3D(1,
kernel_size=5,
trainable=True,
padding='SAME',
input_shape=(None, nc, nc, nc, cell_size))
def encode_embedding_input(input_layer):
conv1_size, conv2_size = (CONV_SIZES[2], CONV_SIZES[1])
input_layer = GaussianNoise(stddev=.1)(input_layer)
conv1 = Conv1D(conv1_size, (2,), activation='mish', padding='same')(input_layer)
pool1 = MaxPooling1D((2,), padding='same')(conv1)
conv2 = Conv1D(conv2_size, (2,), activation='mish', padding='same')(pool1)
pool2 = MaxPooling1D((2,), padding='same')(conv2)
return Flatten()(pool2)
def mlstm_fcn(config: Union[str,
SoccerSageConfig] = SoccerSageConfig()) -> Model:
'''Load and train the MLSTM-FCN model.
Source: https://github.com/titu1994/MLSTM-FCN/blob/master/eeg_model.py
Args:
config: The configuration data.
Returns:
Model: A model in TensorFlow.
'''
if isinstance(config, str):
config = SoccerSageConfig.from_yaml(config)
n_classes = config.num_results
if config.classifier_type == 'total_goals':
n_classes = config.num_goals
ip = Input(shape=(config.time_steps, config.feature_size))
x = Permute((2, 1))(ip)
#x = Masking(mask_value=config.masking_value)(x)
x = LSTM(64)(ip)
x = Dropout(0.8)(x)
y = Conv1D(128, 8, padding='same', kernel_initializer='he_uniform')(ip)
y = BatchNormalization()(y)
y = Activation('relu')(y)
y = squeeze_excite_block(y)
y = Conv1D(256, 5, padding='same', kernel_initializer='he_uniform')(y)
y = BatchNormalization()(y)
y = Activation('relu')(y)
y = squeeze_excite_block(y)
y = Conv1D(128, 3, padding='same', kernel_initializer='he_uniform')(y)
y = BatchNormalization()(y)
y = Activation('relu')(y)
y = GlobalAveragePooling1D()(y)
x = concatenate([x, y])
out = Dense(n_classes, activation='softmax')(x)
classifier = Model(ip, out)
classifier.compile(
loss='categorical_crossentropy',
optimizer=tf.keras.optimizers.Adam(lr=config.learning_rate),
metrics=['accuracy', ranked_probability_score])
if config.pretrained_classifier:
files = SoccerSageFiles(config)
classifier.load_weights(files.model_weights)
return classifier
def __init__(self, vocab_size, embedding_dim=20):
super().__init__(self)
self.embedding = Embedding(vocab_size + 1, embedding_dim)
self.conv1d_32 = Conv1D(32, 3, activation='relu')
self.conv1d_64 = Conv1D(64, 3, activation='relu')
self.conv1d_128 = Conv1D(128, 3, activation='relu')
self.max_pooling = MaxPooling1D(4)
self.global_max_pooling = GlobalMaxPooling1D()
self.dense = Dense(4, activation='softmax')
def get_cnn1d_tx_relu(output_size, img_height, img_width, show=True):
# value with same Tx would use in same channel
model_input = Input(shape=(img_height * img_width, ), name='Main_input')
x = Reshape((img_height, img_width), name='Reshape_1')(model_input)
x = Permute((2, 1), name='Permute_1')(x)
x = Conv1D(filters=256,
kernel_size=11,
strides=1,
padding='same',
activation='relu',
name='Conv1D_relu_1')(x)
x = Conv1D(filters=128,
kernel_size=5,
strides=1,
padding='same',
activation='relu',
name='Conv1D_relu_2')(x)
x = Conv1D(filters=64,
kernel_size=3,
strides=1,
padding='same',
activation='relu',
name='Conv1D_relu_3')(x)
x = Conv1D(filters=32,
kernel_size=3,
strides=1,
padding='same',
activation='relu',
name='Conv1D_relu_4')(x)
x = Conv1D(filters=16,
kernel_size=3,
strides=1,
padding='same',
activation='relu',
name='Conv1D_relu_5')(x)
# x = Conv1D(filters=8, kernel_size=48, strides=1,
# padding='same', activation='relu',
# name='Conv1D_relu_6')(x)
x = Flatten(name='Flatten_1')(x)
x = Dense(512, activation='relu', name='Dense_relu_1')(x)
x = Dense(512, activation='relu', name='Dense_relu_2')(x)
# x = Dense(512, activation='relu', name='Dense_relu_3')(x)
cnn1d_output = Dense(output_size,
activation='linear',
name='Output_Dense_linear')(x)
cnn1d = Model(inputs=model_input,
outputs=cnn1d_output,
name='CNN1D_Tx_relu')
if show:
print('CNN1D Tx summary:')
cnn1d.summary()
print()
return cnn1d
def create_convolutional_encoder(input_shape):
reshape = Reshape(target_shape=(INPUT_LENGTH, 1), input_shape=(INPUT_LENGTH,))(input_shape)
conv1 = Conv1D(filters=32, kernel_size=30, activation='relu', input_shape=(INPUT_LENGTH, 1))(reshape)
conv1 = MaxPooling1D(pool_size=10)(conv1)
conv1 = BatchNormalization()(conv1)
conv2 = Conv1D(filters=64, kernel_size=30, activation='relu')(conv1)
conv2 = MaxPooling1D(pool_size=10)(conv2)
conv2 = BatchNormalization()(conv2)
return conv2