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