def neural_network(n_units, n_input, n_features, train_generator,
validation_generator):
model = Sequential()
model.add(
Bidirectional(CuDNNLSTM(int(n_units), return_sequences=True),
input_shape=(n_input, n_features)))
model.add(Bidirectional(CuDNNLSTM(int(n_units / 2))))
# model.add(Dense(int(n_features/256), 'relu'))
# model.add(Dense(int(n_features/128), 'relu'))
model.add(Dense(n_features))
early_stop = EarlyStopping(monitor='val_loss', patience=20)
reduce_lr = ReduceLROnPlateau(monitor='val_loss',
factor=0.1,
patience=20,
min_lr=0.001)
checkpoint = ModelCheckpoint('model.h5',
monitor='val_loss',
save_best_only=True,
mode='min')
model.compile('adam',
loss='mse',
metrics=[tf.keras.metrics.RootMeanSquaredError()])
model.summary()
history = model.fit(train_generator,
epochs=500,
verbose=1,
validation_data=validation_generator,
callbacks=[checkpoint, reduce_lr, early_stop])
return model, history
def get_model(self):
# Define an input sequence and process it.
self.encoder_inputs = Input(shape=(None, self.num_encoder_tokens))
# Use CuDNNLSTM if running on GPU
if tf.test.is_gpu_available():
encoder = CuDNNLSTM(self.latent_dim, return_state=True)
else:
encoder = LSTM(self.latent_dim, return_state=True)
encoder_outputs, state_h, state_c = encoder(self.encoder_inputs)
# We discard `encoder_outputs` and only keep the states.
self.encoder_states = [state_h, state_c]
# Set up the decoder, using `encoder_states` as initial state.
self.decoder_inputs = Input(shape=(None, self.num_decoder_tokens))
# We set up our decoder to return full output sequences,
# and to return internal states as well. We don't use the
# return states in the training model, but we will use them in inference.
if tf.test.is_gpu_available():
self.decoder_lstm = CuDNNLSTM(self.latent_dim,
return_sequences=True,
return_state=True)
else:
self.decoder_lstm = LSTM(self.latent_dim,
return_sequences=True,
return_state=True)
decoder_outputs, _, _ = self.decoder_lstm(
self.decoder_inputs, initial_state=self.encoder_states)
self.decoder_dense = Dense(self.num_decoder_tokens,
activation="softmax")
decoder_outputs = self.decoder_dense(decoder_outputs)
return Model([self.encoder_inputs, self.decoder_inputs],
decoder_outputs)
def conv_lstm_network(input_shape):
inputs = Input(shape=input_shape, name='input')
x = Reshape((int(input_shape[0]), int(input_shape[1]), 1))(inputs)
x = Conv2D(4, (1, 3), activation='relu', padding='same')(inputs)
x = Dropout(0.1)(x)
x = MaxPooling2D(pool_size=(1, 2))(x)
x = Conv2D(4, (1, 5), activation='relu', padding='same')(inputs)
x = Dropout(0.1)(x)
x = MaxPooling2D(pool_size=(1, 2))(x)
x = Conv2D(4, (1, 3), activation='relu', padding='same')(x)
x = Dropout(0.1)(x)
x = Conv2D(1, (1, 1), activation='relu', padding='same')(x)
a = int(input_shape[0])
b = int(int(input_shape[1]) / 4)
x = Reshape((a, b))(x)
x = Permute((2, 1))(x)
x = CuDNNLSTM(units=32, input_shape=(b, a), return_sequences=True)(x)
x = CuDNNLSTM(units=32, input_shape=(b, a))(x)
x = Flatten()(x)
x = Dense(128, activation='relu', name='output')(x)
outputs = x
return Model(inputs, outputs)
def build_model(lr = 0.0, lr_d = 0.0, units = 0, dr = 0.0):
inp = Input(shape = (max_len,))
x = Embedding(size, embed_size, weights = [embedding_vectors], trainable = False)(inp)
x1 = SpatialDropout1D(dr)(x)
x_cnn = Conv1D(filters=100, kernel_size=4, padding='same', activation='relu')(x1)
x_cnn = BatchNormalization()(x1)
x_cnn = MaxPooling1D(pool_size=2)(x1)
x_cnn = SpatialDropout1D(0.25)(x1)
x1 = Bidirectional(CuDNNLSTM(units, return_sequences = True))(x_cnn)
avg_pool1_cnn = GlobalAveragePooling1D()(x1)
max_pool1_cnn = GlobalMaxPooling1D()(x1)
x_lstm = Bidirectional(CuDNNLSTM(units, return_sequences = True))(x1)
x_lstm = BatchNormalization()(x1)
x_lstm = MaxPooling1D(pool_size=2)(x1)
x_lstm = SpatialDropout1D(0.25)(x1)
x2 = Conv1D(32, kernel_size=3, padding='valid', kernel_initializer='he_uniform')(x_lstm)
avg_pool1_lstm = GlobalAveragePooling1D()(x2)
max_pool1_lstm = GlobalMaxPooling1D()(x2)
x = concatenate([avg_pool1_cnn, max_pool1_cnn, avg_pool1_lstm, max_pool1_lstm])
x = BatchNormalization()(x)
x = Dropout(0.2)(Dense(128,activation='relu') (x))
x = BatchNormalization()(x)
x = Dropout(0.2)(Dense(100,activation='relu') (x))
x = Dense(1, activation = "sigmoid")(x)
model = Model(inputs = inp, outputs = x)
model.compile(loss = "binary_crossentropy", optimizer = Adam(lr = lr, decay = lr_d), metrics = ["accuracy"])
return model
def gru_keras(max_features,
maxlen,
bidirectional,
dropout_rate,
embed_dim,
rec_units,
mtype='GRU',
reduction=None,
classes=4,
lr=0.001):
if K.backend == 'tensorflow':
K.clear_session()
input_layer = Input(shape=(maxlen, ))
embedding_layer = Embedding(max_features,
output_dim=embed_dim,
trainable=True)(input_layer)
x = SpatialDropout1D(dropout_rate)(embedding_layer)
if reduction:
if mtype == 'GRU':
if bidirectional:
x = Bidirectional(
CuDNNGRU(units=rec_units, return_sequences=True))(x)
else:
x = CuDNNGRU(units=rec_units, return_sequences=True)(x)
elif mtype == 'LSTM':
if bidirectional:
x = Bidirectional(
CuDNNLSTM(units=rec_units, return_sequences=True))(x)
else:
x = CuDNNLSTM(units=rec_units, return_sequences=True)(x)
if reduction == 'average':
x = GlobalAveragePooling1D()(x)
elif reduction == 'maximum':
x = GlobalMaxPool1D()(x)
else:
if mtype == 'GRU':
if bidirectional:
x = Bidirectional(
CuDNNGRU(units=rec_units, return_sequences=False))(x)
else:
x = CuDNNGRU(units=rec_units, return_sequences=False)(x)
elif mtype == 'LSTM':
if bidirectional:
x = Bidirectional(
CuDNNLSTM(units=rec_units, return_sequences=False))(x)
else:
x = CuDNNLSTM(units=rec_units, return_sequences=False)(x)
output_layer = Dense(classes, activation="sigmoid")(x)
model = Model(inputs=input_layer, outputs=output_layer)
model.compile(loss='categorical_crossentropy',
optimizer=RMSprop(learning_rate=lr, clipvalue=1, clipnorm=1),
metrics=['acc'])
return model
def build_lstm_model(input_data, output_size, neurons=20, activ_func='linear',
dropout=0.25, loss='mae', optimizer='adam'):
model = Sequential()
model.add(CuDNNLSTM(neurons, input_shape=(input_data.shape[1], input_data.shape[2]), return_sequences=True))
model.add(Dropout(dropout))
model.add(CuDNNLSTM(neurons, input_shape=(input_data.shape[1], input_data.shape[2])))
model.add(Dropout(dropout))
model.add(Dense(units=output_size))
model.add(Activation(activ_func))
model.compile(loss=loss, optimizer=optimizer)
return model
def lstm_network(input_shape):
inputs = Input(shape=(input_shape), name='input')
x = Permute((2, 1))(inputs)
x = CuDNNLSTM(units=32, return_sequences=True)(x)
x = Dropout(0.2)(x)
x = CuDNNLSTM(units=32)(x)
x = Flatten()(x)
x = Dense(128, activation='relu', name='output')(x)
outputs = x
return Model(inputs, outputs)
def build_model(seq_len, vocab_size):
model = Sequential()
model.add(
CuDNNLSTM(units=128,
return_sequences=True,
input_shape=(seq_len, vocab_size)))
model.add(Dropout(0.2))
model.add(CuDNNLSTM(units=128))
model.add(Dropout(0.2))
model.add(Dense(units=64, activation='relu'))
model.add(Dropout(0.2))
model.add(Dense(units=vocab_size, activation='softmax'))
return model
def Build_RNN_layer(Parametre_layer):
if Parametre_layer["type_cell"] == "LSTM":
cell = L.LSTM(units=Parametre_layer["units"],
dropout=Parametre_layer["dropout"],
recurrent_dropout=Parametre_layer["recurrent_dropout"],
return_sequences=True,
return_state=True,
stateful=Parametre_layer["stateful"],
unroll=Parametre_layer["unroll"])
elif Parametre_layer["type_cell"] == "CuDNNGRU":
cell = CuDNNGRU(units=Parametre_layer["units"],
dropout=Parametre_layer["dropout"],
recurrent_dropout=Parametre_layer["recurrent_dropout"],
return_sequences=True,
return_state=True,
stateful=Parametre_layer["stateful"],
unroll=Parametre_layer["unroll"])
elif Parametre_layer["type_cell"] == "GRU":
cell = L.GRU(units=Parametre_layer["units"],
return_sequences=True,
return_state=True,
stateful=Parametre_layer["stateful"])
else: #by default CuDNNLSTM
cell = CuDNNLSTM(units=Parametre_layer["units"],
return_sequences=True,
return_state=True,
stateful=Parametre_layer["stateful"])
return cell
def __init__(self, LAYER_SIZE, LATENT_DIM, P_DROPOUT):
super(TRAJECTORY_ENCODER_LSTM, self).__init__()
self.bi_lstm = Bidirectional(CuDNNLSTM(LAYER_SIZE, return_sequences=True), merge_mode=None)
self.mu = Dense(LATENT_DIM)
self.scale = Dense(LATENT_DIM, activation='softplus')
self.dropout1 = tf.keras.layers.Dropout(P_DROPOUT)
def __decoder1(time_size, freq_size):
timesteps = constants.MAX_SAMPLES // time_size
n_features = freq_size # same value as the output layer of encoder
# Architecture
input_rnn = keras.layers.Input(shape=(timesteps, n_features),
name='Decoder_Input')
lstm = CuDNNLSTM(units=50, return_sequences=True,
name='LSTM_1')(input_rnn)
flat = keras.layers.Flatten(name='Flattener')(lstm)
dense = keras.layers.Dense(256, name='Dense_1',
activation='relu')(flat)
output_rnn = keras.layers.Dense(timesteps,
activation='sigmoid',
name='Decoder_Output_Dense')(dense)
model = keras.Model(name='LSTM-PCA-1',
inputs=input_rnn,
outputs=output_rnn)
loss = keras.losses.binary_crossentropy
accuracy = keras.metrics.binary_accuracy
optimiser = keras.optimizers.SGD(lr=0.001,
decay=1e-6,
momentum=0.9,
nesterov=True)
metrics_names = [loss.__name__, accuracy.__name__]
model.compile(optimizer=optimiser, loss=loss, metrics=[loss, accuracy])
return model, metrics_names
def _add_core(self):
# Doing this on purpose. The old LSTM implementation was faster than the new one
v1rnn = self._training_parameter.get("v1RNN", False)
for idx in range(self._model_parameter["lstm_depth"]):
if v1rnn:
lstm = CuDNNLSTM(
units=self._model_parameter["lstm_width"],
return_sequences=True,
name="CoreLayer{idx}" % idx,
)
else:
lstm = LSTM(
units=self._model_parameter["lstm_width"],
return_sequences=True,
dropout=self._training_parameter["dropout_rate"],
name="CoreLayer%d" % idx,
)
if "bidirectional" in self._model_parameter:
merge_mode = "concat"
if "merge_mode" in self._model_parameter:
merge_mode = self._model_parameter["merge_mode"]
if self._model_parameter["bidirectional"]:
lstm = Bidirectional(lstm, merge_mode=merge_mode)
self._model.add(lstm)
def discriminator(self):
model = ksm.Sequential()
model.add(CuDNNLSTM(512, input_shape=self.shape,
return_sequences=True)) #LSTM architecture
model.add(ksl.Bidirectional(CuDNNLSTM(512)))
model.add(ksl.Dense(512)) # densely connectly layer
model.add(ksl.LeakyReLU(alpha=0.3))
model.add(ksl.Dense(256))
model.add(ksl.LeakyReLU(alpha=0.3))
model.add(ksl.Dense(1, activation='sigmoid'))
model.summary()
s = ksl.Input(shape=self.shape)
v = model(s)
return ksm.Model(s, v)
def gpuLSTM(nodes, **kwargs):
return CuDNNLSTM(nodes,
kernel_initializer="random_uniform",
bias_initializer="ones",
recurrent_regularizer=self.regularization,
stateful=False,
**kwargs)
def __decoder1(self, time_size, freq_size):
timesteps = constants.MAX_SAMPLES // time_size
n_features = freq_size # same value as the output layer of encoder
decoder_in = keras.layers.Input(shape=(timesteps, n_features), name='Decoder_Input')
lstm = CuDNNLSTM(units=128, return_sequences=True, name='lstm')(decoder_in)
flat = keras.layers.Flatten(name='rnn_flat')(lstm)
dense1 = keras.layers.Dense(512, name='rnn_dense_1')(flat)
leaky1 = keras.layers.LeakyReLU(name='rnn_leaky_1')(dense1)
decoder_out = keras.layers.Dense(timesteps, activation='sigmoid', name='dense_dec_out')(leaky1)
model = keras.Model(name='TrainedCNN_with_GRU', inputs=decoder_in, outputs=decoder_out)
loss = keras.losses.binary_crossentropy
accuracy = keras.metrics.binary_accuracy
optimiser = keras.optimizers.SGD(lr=0.001, decay=1e-6, momentum=0.9, nesterov=True)
model.compile(optimizer=optimiser, loss=loss, metrics=[accuracy])
metrics_names = [loss.__name__, accuracy.__name__]
return model, metrics_names
def __init__(self, LAYER_SIZE, ACTION_DIM, OBS_DIM, NUM_DISTRIBUTIONS, NUM_QUANTISATIONS, DISCRETIZED, P_DROPOUT):
super(ACTOR, self).__init__()
self.ACTION_DIM = ACTION_DIM-1
self.OBS_DIM = OBS_DIM
self.NUM_DISTRIBUTIONS = NUM_DISTRIBUTIONS
self.DISCRETIZED = DISCRETIZED
self.NUM_QUANTISATIONS = NUM_QUANTISATIONS
self.RNN1 = CuDNNLSTM(LAYER_SIZE, return_sequences=True, return_state = True)
self.RNN2 = CuDNNLSTM(LAYER_SIZE, return_sequences=True, return_state = True)
self.mu = Dense(self.ACTION_DIM*self.NUM_DISTRIBUTIONS) #means of our logistic distributions
# softplus activations are to ensure positive values for scale and probability weighting.
self.scale = Dense(self.ACTION_DIM*self.NUM_DISTRIBUTIONS,activation='softplus') # scales of our logistic distrib
self.prob_weight = Dense(self.ACTION_DIM*self.NUM_DISTRIBUTIONS,activation='softplus') # weightings on each of the distribs.
# self.next_obs_pred = Dense(self.OBS_DIM)
self.gripper = Dense(1)
self.dropout1 = tf.keras.layers.Dropout(P_DROPOUT)
def BiLSTMAttention(vocab_size, max_len):
inputs = Input((max_len))
x = Embedding(input_dim=vocab_size, output_dim=64)(inputs)
x = Bidirectional(CuDNNLSTM(64, return_sequences=True),
merge_mode='sum')(x)
x = Bidirectional(CuDNNLSTM(64, return_sequences=True),
merge_mode='sum')(x)
x = TimeDistributed(Dense(1, activation='relu'))(x)
x = Flatten()(x)
outputs = Dense(1, activation='sigmoid')(x)
model = Model(inputs=inputs, outputs=outputs)
model.compile(loss='binary_crossentropy',
optimizer='adam',
metrics=['accuracy'])
return model
def __init__(self, input_size, slot_size, intent_size, layer_size=128):
super(BaselineModel, self).__init__()
self.embedding = tf.keras.layers.Embedding(input_size, layer_size)
self.bilstm = tf.keras.layers.Bidirectional(
CuDNNLSTM(layer_size, return_sequences=True, return_state=True))
self.dropout = CustomDropout.CustomDropout(0.5)
self.intent_out = tf.keras.layers.Dense(intent_size, activation=None)
self.slot_out = tf.keras.layers.TimeDistributed(
tf.keras.layers.Dense(slot_size, activation=None))
def build_rnn_classifier(n_lstm_layers,
lstm_layer_size,
n_hiden_layers,
hidden_layer_size,
optimizer='adam',
input_shape=None):
''' function to build the RNN architecture '''
# intialize a classifier
classifier = Sequential()
# # input layer
# classifier.add( Input(shape=input_shape) )
# frist lstm layers
for n in range(n_lstm_layers - 1):
classifier.add(CuDNNLSTM(units=lstm_layer_size, return_sequences=True))
# last lstm layer
classifier.add(
CuDNNLSTM(units=lstm_layer_size,
return_sequences=False,
input_shape=input_shape))
# hidden layers
for n in range(n_hiden_layers):
classifier.add(
Dense(units=hidden_layer_size,
kernel_initializer='uniform',
activation='relu'))
# each next hidden layer of the network will be 50% smaller
hidden_layer_size /= hidden_layer_size
# output layer
classifier.add(
Dense(units=1, kernel_initializer='uniform', activation='sigmoid'))
# compile model
classifier.compile(optimizer=optimizer,
loss='binary_crossentropy',
metrics=['accuracy'])
return classifier
def LSTMEncoderDecoder(self, enconderUnits, decoderUnits, denseUnits,
dropout, n_timesteps, n_features, n_outputs):
model = Sequential()
#ENCODER
model.add(
CuDNNLSTM(enconderUnits, input_shape=(n_timesteps, n_features)))
model.add(Dropout(dropout))
model.add(RepeatVector(n_outputs))
#DECODER
model.add(CuDNNLSTM(decoderUnits, return_sequences=True))
model.add(Dropout(dropout))
model.add(CuDNNLSTM(int(decoderUnits / 2), return_sequences=True))
model.add(Dropout(dropout))
#OUTPUT
model.add(TimeDistributed(Dense(denseUnits, activation='relu')))
model.add(TimeDistributed(Dense(1)))
return model
def build_lstm_mnist(input_shape, output_size):
"""Build a small LSTM to recognize MNIST digits as permuted sequences"""
model = Sequential([
CuDNNLSTM(128, input_shape=input_shape),
Dense(output_size),
Activation("softmax")
])
model.compile(optimizer="adam",
loss="categorical_crossentropy",
metrics=["accuracy"])
return model
def build_model(self):
"""
Build the model based on the params
"""
print('-> Building model')
inputs = Input(shape=(self.seq_len, self.emb_len), name='inputs')
# add a RNN layer
# bidirectional not working yet
if self.rnn_style == 'GRU' and self.bidirectional:
encoder_output, hidden_state, _ = Bidirectional(
GRU(units=self.rnn_size,
return_sequences=True,
return_state=True,
name='GRUbi'))(inputs)
elif self.rnn_style == 'GRU' and not self.bidirectional:
encoder_output, hidden_state = GRU(units=self.rnn_size,
return_sequences=True,
return_state=True,
name='GRU')(inputs)
elif self.rnn_style == 'CuDNNLSTM':
encoder_output, hidden_state, c_state = CuDNNLSTM(
units=self.rnn_size,
return_sequences=True,
return_state=True,
name='CuDNNLSTM')(inputs)
elif self.rnn_style is None:
# full attention model
encoder_output, attention_weights = Attention(
context='many-to-many', name='Attention in')(inputs)
# concat for use as input
attention_input = [encoder_output, hidden_state]
# get attention and flatten
encoder_output, attention_weights = Attention(
context='many-to-one',
alignment_type='local-p*',
window_width=25,
name='Attention')(attention_input)
encoder_output = Flatten(name='Flatten')(encoder_output)
# against overfitting etc
x = BatchNormalization(name='BatchNormalization')(encoder_output)
x = Dropout(self.dropout_rate, name='Dropout')(x)
predictions = Dense(self.emb_len, activation='softmax',
name='Dense')(x)
# define the model
self.model = Model(inputs=inputs, outputs=predictions)
print(self.model.summary())
def pyramid_lstm_network(input_shape):
inputs = Input(shape=input_shape, name='input')
x = Reshape((int(input_shape[0]), int(input_shape[1]), 1))(inputs)
x1 = Conv2D(8, (1, 3), activation='relu', padding='same')(x)
x1 = Dropout(0.1)(x1)
x1 = MaxPooling2D(pool_size=(1, 2))(x1)
x2 = Conv2D(8, (1, 3), activation='relu', padding='same')(x1)
x2 = Dropout(0.1)(x2)
x2 = MaxPooling2D(pool_size=(1, 2))(x2)
x3 = Conv2D(8, (1, 3), activation='relu', padding='same')(x2)
x3 = Dropout(0.1)(x3)
x3 = MaxPooling2D(pool_size=(1, 2))(x3)
y3 = Conv2D(1, (1, 1), activation='relu', padding='same')(x3)
temp = UpSampling2D(size=(1, 2))(y3)
y2 = Conv2D(1, (1, 1), activation='relu', padding='same')(x2)
y2 = Add()([y2, temp])
temp = UpSampling2D(size=(1, 2))(y2)
y1 = Conv2D(1, (1, 1), activation='relu', padding='same')(x1)
y1 = Add()([y1, temp])
a = int(input_shape[0])
b = int(int(input_shape[1] / 2))
y1 = Reshape((a, b))(y1)
y1 = Permute((2, 1))(y1)
y1 = CuDNNLSTM(units=32, input_shape=(b, a), return_sequences=True)(y1)
y1 = CuDNNLSTM(units=32, input_shape=(b, a))(y1)
x = Flatten()(y1)
x = Dense(128, activation='relu', name='output')(x)
outputs = x
return Model(inputs, outputs)
def get_model(gpus):
input_dim = 80
is_gpu = len(gpus) > 0
output_dim = 28
context = 7
units = 1024
dropouts = [0.1, .1, 0]
#random_state = 1
#np.random.seed(1)
#tensorflow.random.set_seed(random_state)
input_tensor = Input([None, input_dim],
name='X') # Define input tensor [time, features]
x = Lambda(expand_dims,
arguments=dict(axis=-1))(input_tensor) # Add 4th dim (channel)
x = ZeroPadding2D(padding=(context,
0))(x) # Fill zeros around time dimension
receptive_field = (2 * context + 1, input_dim
) # Take into account fore/back-ward context
x = Conv2D(filters=units,
kernel_size=receptive_field)(x) # Convolve signal in time dim
x = Lambda(squeeze,
arguments=dict(axis=2))(x) # Squeeze into 3rd dim array
x = ReLU(max_value=20)(x) # Add non-linearity
x = Dropout(rate=dropouts[0])(x) # Use dropout as regularization
x = TimeDistributed(Dense(units))(x) # 2nd and 3rd FC layers do a feature
x = ReLU(max_value=20)(x) # extraction base on the context
x = Dropout(rate=dropouts[1])(x)
x = TimeDistributed(Dense(units))(x)
x = ReLU(max_value=20)(x)
x = Dropout(rate=dropouts[2])(x)
x = Bidirectional(
CuDNNLSTM(units, return_sequences=True)
if is_gpu else # LSTM handle long dependencies
LSTM(
units,
return_sequences=True,
),
merge_mode='sum')(x)
output_tensor = TimeDistributed(Dense(output_dim, activation='softmax'))(
x) # Return at each time step prob along characters
model = Model(inputs=input_tensor, outputs=output_tensor)
return model
def __init__(self, input_size, slot_size, intent_size, layer_size=128):
super(SlotGatedModel, self).__init__()
self.embedding = tf.keras.layers.Embedding(input_size, layer_size)
self.bilstm = tf.keras.layers.Bidirectional(
CuDNNLSTM(layer_size, return_sequences=True, return_state=True))
self.dropout = CustomDropout.CustomDropout(0.5)
self.attn_size = 2 * layer_size
self.slot_att = CustomBahdanauAttention.CustomBahdanauAttention(
self.attn_size)
self.intent_att = BahdanauAttention.BahdanauAttention(self.attn_size)
self.slot_gate = SlotGate.SlotGate(self.attn_size)
self.intent_out = tf.keras.layers.Dense(intent_size, activation=None)
self.slot_out = tf.keras.layers.TimeDistributed(
tf.keras.layers.Dense(slot_size, activation=None))
def drugSeq(self, input_shape):
input_drug = Input(shape=(input_shape, ))
emb_drug = Embedding(44, 128, input_length=150)(input_drug)
conv_drug_1 = Conv1D(filters=32,
kernel_size=3,
padding='same',
activation='relu')(emb_drug)
pool_drug_1 = MaxPooling1D(pool_size=2)(conv_drug_1)
att_in_drug = Bidirectional(
CuDNNLSTM(32,
kernel_regularizer=l2(0.02),
return_sequences=True,
recurrent_regularizer=l2(0.02),
bias_regularizer=l2(0.02)))(pool_drug_1)
att_out_drug = attention()(att_in_drug)
return input_drug, att_out_drug
def get_model(self):
# Define an input sequence and process it.
self.lstm_inputs = Input(shape=(None, self.num_tokens))
self.lstm = CuDNNLSTM(self.latent_dim,
return_state=True,
return_sequences=True)
lstm_outputs, state_h, state_c = self.lstm(self.lstm_inputs)
self.lstm_states = [state_h, state_c]
self.dense = Dense(self.num_tokens, activation='softmax')
lstm_outputs = self.dense(lstm_outputs)
self.model = Model(self.lstm_inputs, lstm_outputs)
return self.model
def protSeq(self, input_shape):
input_target = Input(shape=(input_shape, ))
emb_target = Embedding(21, 128, input_length=1000)(input_target)
conv_target_1 = Conv1D(filters=32,
kernel_size=3,
padding='same',
activation='relu')(emb_target)
pool_target_1 = MaxPooling1D(pool_size=2)(conv_target_1)
att_in_target = Bidirectional(
CuDNNLSTM(32,
kernel_regularizer=l2(0.01),
return_sequences=True,
recurrent_regularizer=l2(0.01),
bias_regularizer=l2(0.01)))(pool_target_1)
att_out_target = attention()(att_in_target)
return input_target, att_out_target
def lstm_model():
x_input = Input(shape=(100, ))
emb = Embedding(21, 128, input_length=100)(x_input)
bi_rnn = Bidirectional(
CuDNNLSTM(64,
kernel_regularizer=l2(0.00001),
recurrent_regularizer=l2(0.00001),
bias_regularizer=l2(0.00001)))(emb)
x1 = Dropout(0.3)(bi_rnn)
# softmax classifier
x_output = Dense(9, activation='softmax')(x1)
model1 = Model(inputs=x_input, outputs=x_output)
# model1.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])
model1.compile(optimizer='adam',
loss='categorical_crossentropy',
metrics=[precision])
return model1
def get_model(embedding_matrix, max_len, max_features, embed_size):
inp = Input(shape=(max_len, ))
x = Embedding(max_features, embed_size, weights=[embedding_matrix])(inp)
x = CuDNNGRU(64, return_sequences=True)(x)
x = Bidirectional(CuDNNLSTM(64, return_sequences=True))(x)
avg_pool = GlobalAveragePooling1D()(x)
max_pool = GlobalMaxPooling1D()(x)
conc = concatenate([avg_pool, max_pool])
conc = Dense(64, activation="relu")(conc)
conc = Dropout(0.1)(conc)
outp = Dense(1, activation="sigmoid")(conc)
model = Model(inputs=inp, outputs=outp)
model.compile(loss='binary_crossentropy',
optimizer=tf.optimizers.Adam(learning_rate=0.005),
metrics=['AUC'])
return model
