我们从Python开源项目中，提取了以下32个代码示例，用于说明如何使用keras.layers.wrappers.Bidirectional()。
def lstm_word_model(self): embed_input = Input(shape=(self.opt['max_sequence_length'], self.opt['embedding_dim'],)) output = Bidirectional(LSTM(self.opt['units_lstm'], activation='tanh', kernel_regularizer=l2(self.opt['regul_coef_lstm']), dropout=self.opt['dropout_rate']))(embed_input) output = Dropout(rate=self.opt['dropout_rate'])(output) output = Dense(self.opt['dense_dim'], activation=None, kernel_regularizer=l2(self.opt['regul_coef_dense']))(output) output = BatchNormalization()(output) output = Activation('relu')(output) output = Dropout(rate=self.opt['dropout_rate'])(output) output = Dense(1, activation=None, kernel_regularizer=l2(self.opt['regul_coef_dense']))(output) output = BatchNormalization()(output) act_output = Activation('sigmoid')(output) model = Model(inputs=embed_input, outputs=act_output) return model
def create_lstm_layer_1(self, input_dim): """Create a LSTM layer of a model.""" inp = Input(shape=(input_dim, self.embedding_dim,)) inp_drop = Dropout(self.ldrop_val)(inp) ker_in = glorot_uniform(seed=self.seed) rec_in = Orthogonal(seed=self.seed) bioutp = Bidirectional(LSTM(self.hidden_dim, input_shape=(input_dim, self.embedding_dim,), kernel_regularizer=None, recurrent_regularizer=None, bias_regularizer=None, activity_regularizer=None, recurrent_dropout=self.recdrop_val, dropout=self.inpdrop_val, kernel_initializer=ker_in, recurrent_initializer=rec_in, return_sequences=True), merge_mode=None)(inp_drop) dropout_forw = Dropout(self.dropout_val)(bioutp[0]) dropout_back = Dropout(self.dropout_val)(bioutp[1]) model = Model(inputs=inp, outputs=[dropout_forw, dropout_back], name="biLSTM_encoder") return model
def create_lstm_layer_2(self, input_dim): """Create a LSTM layer of a model.""" inp = Input(shape=(input_dim, 2*self.perspective_num,)) inp_drop = Dropout(self.ldrop_val)(inp) ker_in = glorot_uniform(seed=self.seed) rec_in = Orthogonal(seed=self.seed) bioutp = Bidirectional(LSTM(self.aggregation_dim, input_shape=(input_dim, 2*self.perspective_num,), kernel_regularizer=None, recurrent_regularizer=None, bias_regularizer=None, activity_regularizer=None, recurrent_dropout=self.recdrop_val, dropout=self.inpdrop_val, kernel_initializer=ker_in, recurrent_initializer=rec_in, return_sequences=True), merge_mode=None)(inp_drop) dropout_forw = Dropout(self.dropout_val)(bioutp[0]) dropout_back = Dropout(self.dropout_val)(bioutp[1]) model = Model(inputs=inp, outputs=[dropout_forw, dropout_back], name="biLSTM_enc_persp") return model
def create_lstm_layer_last(self, input_dim): """Create a LSTM layer of a model.""" inp = Input(shape=(input_dim, self.embedding_dim,)) inp_drop = Dropout(self.ldrop_val)(inp) ker_in = glorot_uniform(seed=self.seed) rec_in = Orthogonal(seed=self.seed) bioutp = Bidirectional(LSTM(self.hidden_dim, input_shape=(input_dim, self.embedding_dim,), kernel_regularizer=None, recurrent_regularizer=None, bias_regularizer=None, activity_regularizer=None, recurrent_dropout=self.recdrop_val, dropout=self.inpdrop_val, kernel_initializer=ker_in, recurrent_initializer=rec_in, return_sequences=False), merge_mode='concat')(inp_drop) dropout = Dropout(self.dropout_val)(bioutp) model = Model(inputs=inp, outputs=dropout, name="biLSTM_encoder_last") return model
def _build_sequence_model(self, sequence_input): RNN = GRU if self._rnn_type == 'gru' else LSTM def rnn(): rnn = RNN(units=self._rnn_output_size, return_sequences=True, dropout=self._dropout_rate, recurrent_dropout=self._dropout_rate, kernel_regularizer=self._regularizer, kernel_initializer=self._initializer, implementation=2) rnn = Bidirectional(rnn) if self._bidirectional_rnn else rnn return rnn input_ = sequence_input for _ in range(self._rnn_layers): input_ = BatchNormalization(axis=-1)(input_) rnn_out = rnn()(input_) input_ = rnn_out time_dist_dense = TimeDistributed(Dense(units=self._vocab_size))(rnn_out) return time_dist_dense
def change_trainable(layer, trainable, verbose=False): """ Helper method that fixes some of Keras' issues with wrappers and trainability. Freezes or unfreezes a given layer. # Arguments: layer: Layer to be modified. trainable: Whether the layer should be frozen or unfrozen. verbose: Verbosity flag. """ layer.trainable = trainable if type(layer) == Bidirectional: layer.backward_layer.trainable = trainable layer.forward_layer.trainable = trainable if type(layer) == TimeDistributed: layer.backward_layer.trainable = trainable if verbose: action = 'Unfroze' if trainable else 'Froze' print("{} {}".format(action, layer.name))
def test_tiny_no_sequence_bidir_random(self, model_precision=_MLMODEL_FULL_PRECISION): np.random.seed(1988) input_dim = 1 input_length = 1 num_channels = 1 num_samples = 1 # Define a model model = Sequential() model.add(Bidirectional(LSTM(num_channels, implementation = 1, recurrent_activation = 'sigmoid'), input_shape=(input_length, input_dim))) # Set some random weights model.set_weights([np.random.rand(*w.shape)*0.2-0.1 for w in model.get_weights()]) # Test the keras model self._test_keras_model(model, input_blob = 'data', output_blob = 'output', model_precision=model_precision)
def test_tiny_no_sequence_bidir_random_gpu(self, model_precision = _MLMODEL_FULL_PRECISION): np.random.seed(1988) input_dim = 1 input_length = 1 num_channels = 1 num_samples = 1 # Define a model model = Sequential() model.add(Bidirectional(LSTM(num_channels, implementation = 2, recurrent_activation = 'sigmoid'), input_shape=(input_length, input_dim))) # Set some random weights model.set_weights([np.random.rand(*w.shape)*0.2-0.1 for w in model.get_weights()]) # Test the keras model self._test_keras_model(model, input_blob = 'data', output_blob = 'output', model_precision=model_precision)
def test_small_no_sequence_bidir_random(self): np.random.seed(1988) input_dim = 10 input_length = 1 num_channels = 1 # Define a model model = Sequential() model.add(Bidirectional(LSTM(num_channels, implementation = 2, recurrent_activation = 'sigmoid'), input_shape=(input_length, input_dim))) # Set some random weights model.set_weights([np.random.rand(*w.shape)*0.2-0.1 for w in model.get_weights()]) # Test the keras model self._test_keras_model(model, input_blob = 'data', output_blob = 'output')
def test_medium_bidir_random_return_seq_false(self): np.random.seed(1988) input_dim = 7 input_length = 5 num_channels = 10 # Define a model model = Sequential() model.add(Bidirectional(LSTM(num_channels, return_sequences=False, implementation=2, recurrent_activation='sigmoid'), input_shape=(input_length, input_dim))) # Set some random weights model.set_weights([np.random.rand(*w.shape)*0.2-0.1 for w in model.get_weights()]) # Test the keras model self._test_keras_model(model, input_blob='data', output_blob='output')
def test_medium_bidir_random_return_seq_true(self): np.random.seed(1988) input_dim = 7 input_length = 5 num_channels = 10 # Define a model model = Sequential() model.add(Bidirectional(LSTM(num_channels, return_sequences = True, implementation = 2, recurrent_activation = 'sigmoid'), input_shape=(input_length, input_dim))) # Set some random weights model.set_weights([np.random.rand(*w.shape)*0.2-0.1 for w in model.get_weights()]) # Test the keras model self._test_keras_model(model, input_blob = 'data', output_blob = 'output')
def test_tiny_no_sequence_bidir_random(self): np.random.seed(1988) input_dim = 1 input_length = 1 num_channels = 1 num_samples = 1 # Define a model model = Sequential() model.add(Bidirectional(LSTM(num_channels, input_dim = input_dim, input_length = input_length, consume_less = 'cpu', inner_activation = 'sigmoid'), input_shape=(input_length, input_dim))) # Set some random weights model.set_weights([np.random.rand(*w.shape) for w in model.get_weights()]) # Test the keras model self._test_keras_model(model, input_blob = 'data', output_blob = 'output')
def test_tiny_no_sequence_bidir_random_gpu(self): np.random.seed(1988) input_dim = 1 input_length = 1 num_channels = 1 num_samples = 1 # Define a model model = Sequential() model.add(Bidirectional(LSTM(num_channels, input_dim = input_dim, input_length = input_length, consume_less = 'gpu', inner_activation = 'sigmoid'), input_shape=(input_length, input_dim))) # Set some random weights model.set_weights([np.random.rand(*w.shape) for w in model.get_weights()]) # Test the keras model self._test_keras_model(model, input_blob = 'data', output_blob = 'output')
def test_small_no_sequence_bidir_random(self): np.random.seed(1988) input_dim = 10 input_length = 1 num_channels = 1 # Define a model model = Sequential() model.add(Bidirectional(LSTM(num_channels, input_dim = input_dim, input_length = input_length, consume_less = 'gpu', inner_activation = 'sigmoid'), input_shape=(input_length, input_dim))) # Set some random weights model.set_weights([np.random.rand(*w.shape) for w in model.get_weights()]) # Test the keras model self._test_keras_model(model, input_blob = 'data', output_blob = 'output')
def test_medium_bidir_random_return_seq_false(self): np.random.seed(1988) input_dim = 7 input_length = 5 num_channels = 10 # Define a model model = Sequential() model.add(Bidirectional(LSTM(num_channels, input_dim=input_dim, input_length=input_length, return_sequences=False, consume_less='gpu', inner_activation='sigmoid'), input_shape=(input_length, input_dim))) # Set some random weights model.set_weights([np.random.rand(*w.shape) for w in model.get_weights()]) # Test the keras model self._test_keras_model(model, input_blob='data', output_blob='output')
def test_medium_bidir_random_return_seq_true(self): np.random.seed(1988) input_dim = 7 input_length = 5 num_channels = 10 # Define a model model = Sequential() model.add(Bidirectional(LSTM(num_channels, input_dim = input_dim, input_length = input_length, return_sequences = True, consume_less = 'gpu', inner_activation = 'sigmoid'), input_shape=(input_length, input_dim))) # Set some random weights model.set_weights([np.random.rand(*w.shape) for w in model.get_weights()]) # Test the keras model self._test_keras_model(model, input_blob = 'data', output_blob = 'output')
def main(): print("\n\nLoading data...") data_dir = "/data/translate" vocab_size = 20000 en, fr = prepare_date(data_dir, vocab_size) print("\n\nbuilding the model...") embedding_size = 64 hidden_size = 32 model = Sequential() model.add(Embedding(en.max_features, embedding_size, input_length=en.max_length, mask_zero=True)) model.add(Bidirectional(GRU(hidden_size), merge_mode='sum')) model.add(RepeatVector(fr.max_length)) model.add(GRU(embedding_size)) model.add(Dense(fr.max_length, activation="softmax")) model.compile('rmsprop', 'mse') print(model.get_config()) print("\n\nFitting the model...") model.fit(en.examples, fr.examples) print("\n\nEvaluation...") #TODO
def init(self): self.model = Sequential() self.model.add(Bidirectional(LSTM(126, return_sequences=True), 'sum', input_shape=(self._max_frames, self._features_count))) self.model.add(Dropout(0.5)) self.model.add(TimeDistributed(Dense(units=self._phonemes_count, activation='softmax'))) self.model.compile(loss='categorical_crossentropy', optimizer='rmsprop', metrics=[metrics.categorical_accuracy])
def build_model(chunk_size, feature_len, num_classes, gru_size=128): """Builds a bidirectional GRU model""" model = Sequential() # Bidirectional wrapper takes a copy of the first argument and reverses # the direction. Weights are independent between components. model.add(Bidirectional( GRU(gru_size, activation='tanh', return_sequences=True, name='gru1'), input_shape=(chunk_size, feature_len)) ) model.add(Bidirectional( GRU(gru_size, activation='tanh', return_sequences=True, name='gru2')) ) model.add(Dense(num_classes, activation='softmax', name='classify')) return model
def simpleNMT(pad_length=100, n_chars=105, n_labels=6, embedding_learnable=False, encoder_units=256, decoder_units=256, trainable=True, return_probabilities=False): """ Builds a Neural Machine Translator that has alignment attention :param pad_length: the size of the input sequence :param n_chars: the number of characters in the vocabulary :param n_labels: the number of possible labelings for each character :param embedding_learnable: decides if the one hot embedding should be refinable. :return: keras.models.Model that can be compiled and fit'ed *** REFERENCES *** Lee, Jason, Kyunghyun Cho, and Thomas Hofmann. "Neural Machine Translation By Jointly Learning To Align and Translate" """ input_ = Input(shape=(pad_length,), dtype='float32') input_embed = Embedding(n_chars, n_chars, input_length=pad_length, trainable=embedding_learnable, weights=[np.eye(n_chars)], name='OneHot')(input_) rnn_encoded = Bidirectional(LSTM(encoder_units, return_sequences=True), name='bidirectional_1', merge_mode='concat', trainable=trainable)(input_embed) y_hat = AttentionDecoder(decoder_units, name='attention_decoder_1', output_dim=n_labels, return_probabilities=return_probabilities, trainable=trainable)(rnn_encoded) model = Model(inputs=input_, outputs=y_hat) return model
def __init__(self, hyper_params): # Sequential model model = Sequential() # Embedding layer model.add(Embedding(constant.NUM_CHARS, 5, input_length=hyper_params.num_step)) # LSTM Layer #1 lstm = LSTM(256, return_sequences=True, unroll=True, dropout=0.1, recurrent_dropout=0.1) model.add(Bidirectional(lstm)) model.add(Dropout(0.1)) # LSTM Layer #2 lstm = LSTM(256, return_sequences=True, unroll=True, dropout=0.1, recurrent_dropout=0.1) model.add(Bidirectional(lstm)) model.add(Dropout(0.1)) # LSTM Layer #3 lstm = LSTM(128, return_sequences=True, unroll=True, dropout=0.25, recurrent_dropout=0.25) model.add(Bidirectional(lstm)) model.add(Dropout(0.25)) # RNN model.add(TimeDistributed(Dense(constant.NUM_TAGS, activation="softmax"), input_shape=(hyper_params.num_step, 128))) # Optimizer optimizer = Adam(hyper_params.learning_rate) # Compile model.compile(loss="categorical_crossentropy", optimizer=optimizer, metrics=["categorical_accuracy"]) self.model = model
def create_model(options): post = Input(shape=(options['MAX_LEN'],)) if options['USE_EMBEDDING']: embedding = Embedding(output_dim=options['EMBEDDING_DIM'], weights = [options['EMBEDDING_MATRIX']] ,input_dim = len(options['VOCAB']) + 2, mask_zero=True ) else: embedding = Embedding(output_dim=options['EMBEDDING_DIM'] ,input_dim = len(options['VOCAB']) + 2, mask_zero=True ) embed_post = embedding(post) processed_post = Bidirectional(GRU(options['HIDDEN_DIM'], return_sequences = True))(embed_post) output = Dense(len(options['CLASSES_2_IX']), activation='softmax')(processed_post) model = Model(inputs = [post], outputs = output) adam = Adam(clipnorm=1.) model.compile(optimizer=adam, loss='categorical_crossentropy',metrics=['accuracy']) model.summary() return model
def build(self): dim_data = self.size_of_input_data_dim nb_time_step = self.size_of_input_timesteps news_input = Input(shape=(nb_time_step, dim_data)) lstm = LSTM(output_dim=nb_hidden_units, dropout_U=dropout, dropout_W=dropout, W_regularizer=l2(l2_norm_alpha), b_regularizer=l2(l2_norm_alpha), activation='tanh') bi_lstm = Bidirectional(lstm, input_shape=(nb_time_step, dim_data), merge_mode='concat') all_news_rep = bi_lstm(news_input) news_predictions = Dense(1, activation='linear')(all_news_rep) self.model = Model(news_input, news_predictions, name="deep rnn for financial news analysis")
def text_feature_extract_model1(embedding_size=128, hidden_size=256): ''' this is a model use normal Bi-LSTM and maxpooling extract feature examples: ????????? [ 1.62172219e-05] ???????? [ 1.65377696e-05] ?????,??? [ 1.] ???????? [ 1.] ????????? [ 1.76498161e-05] ??????????????16?12?????????? [ 1.59666997e-05] ??????????????????? [ 1.] ?????????????? [ 1.52662833e-05] ?????????????????????????????????? [ 1.] ???????????????????????????????????????? [ 1.52281245e-05] ?????????????????????????? [ 1.] ??????????? [ 1.59881820e-05] :return: ''' model = Sequential() model.add(Embedding(input_dim=max_features, output_dim=embedding_size, input_length=max_seq)) model.add(Bidirectional(LSTM(hidden_size, return_sequences=True))) model.add(TimeDistributed(Dense(embedding_size/2))) model.add(Activation('softplus')) model.add(MaxPooling1D(5)) model.add(Flatten()) # model.add(Dense(2048, activation='softplus')) # model.add(Dropout(0.2)) model.add(Dense(1, activation='sigmoid')) model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy']) model.summary() plot(model, to_file="text_feature_extract_model1.png", show_shapes=True) return model
def build_generator(l_var, a_var, embeddings): """Builds a question generator model. Args: l_var: keras tensor, the latent vector input. a_var: keras tensor, the answer input. embeddings: numpy array, the embeddings to use for knn decoding. """ latent_var = Input(tensor=l_var, name='latent_var_pl') answer_var = Input(tensor=a_var, name='gen_answer_pl') l_var, a_var = latent_var, answer_var RNN_DIMS = 64 vocab_size, num_embedding_dims = embeddings.shape # Computes context of the answer. a_lstm = Bidirectional(LSTM(RNN_DIMS, return_sequences=True)) a_context = a_lstm(a_var) # Uses context to formulate a question. q_matching_lstm = LSTM(RNN_DIMS, return_sequences=True) q_matching_lstm = RecurrentAttention(q_matching_lstm, a_context) q_var = q_matching_lstm(l_var) q_var = LSTM(RNN_DIMS, return_sequences=True)(q_var) q_var = Dense(num_embedding_dims)(q_var) # Builds the model from the variables (not compiled). model = Model(inputs=[latent_var, answer_var], outputs=[q_var]) return model
def test_Bidirectional(): rnn = recurrent.SimpleRNN nb_sample = 2 dim = 2 timesteps = 2 output_dim = 2 for mode in ['sum', 'concat']: x = np.random.random((nb_sample, timesteps, dim)) target_dim = 2 * output_dim if mode == 'concat' else output_dim y = np.random.random((nb_sample, target_dim)) # test with Sequential model model = Sequential() model.add(wrappers.Bidirectional(rnn(output_dim), merge_mode=mode, input_shape=(timesteps, dim))) model.compile(loss='mse', optimizer='sgd') model.fit(x, y, nb_epoch=1, batch_size=1) # test config model.get_config() model = model_from_json(model.to_json()) model.summary() # test stacked bidirectional layers model = Sequential() model.add(wrappers.Bidirectional(rnn(output_dim, return_sequences=True), merge_mode=mode, input_shape=(timesteps, dim))) model.add(wrappers.Bidirectional(rnn(output_dim), merge_mode=mode)) model.compile(loss='mse', optimizer='sgd') model.fit(x, y, nb_epoch=1, batch_size=1) # test with functional API input = Input((timesteps, dim)) output = wrappers.Bidirectional(rnn(output_dim), merge_mode=mode)(input) model = Model(input, output) model.compile(loss='mse', optimizer='sgd') model.fit(x, y, nb_epoch=1, batch_size=1) # Bidirectional and stateful input = Input(batch_shape=(1, timesteps, dim)) output = wrappers.Bidirectional(rnn(output_dim, stateful=True), merge_mode=mode)(input) model = Model(input, output) model.compile(loss='mse', optimizer='sgd') model.fit(x, y, nb_epoch=1, batch_size=1)
def test_bidir(self): """ Test the conversion of a bidirectional layer """ from keras.layers import LSTM from keras.layers.wrappers import Bidirectional # Create a simple Keras model model = Sequential() model.add(Bidirectional(LSTM(32, input_dim=32, input_length=10), input_shape=(10, 32))) input_names = ['input'] output_names = ['output'] spec = keras.convert(model, input_names, output_names).get_spec() self.assertIsNotNone(spec) # Test the model class self.assertIsNotNone(spec.description) self.assertTrue(spec.HasField('neuralNetwork')) # Test the inputs and outputs self.assertEquals(len(spec.description.input), len(input_names) + 4) self.assertEquals(input_names[0], spec.description.input[0].name) self.assertEquals(32, spec.description.input[1].type.multiArrayType.shape[0]) self.assertEquals(32, spec.description.input[2].type.multiArrayType.shape[0]) self.assertEquals(32, spec.description.input[3].type.multiArrayType.shape[0]) self.assertEquals(32, spec.description.input[4].type.multiArrayType.shape[0]) self.assertEquals(len(spec.description.output), len(output_names) + 4) self.assertEquals(output_names[0], spec.description.output[0].name) self.assertEquals(64, spec.description.output[0].type.multiArrayType.shape[0]) self.assertEquals(32, spec.description.output[1].type.multiArrayType.shape[0]) self.assertEquals(32, spec.description.output[2].type.multiArrayType.shape[0]) self.assertEquals(32, spec.description.output[3].type.multiArrayType.shape[0]) self.assertEquals(32, spec.description.output[4].type.multiArrayType.shape[0]) # Test the layer parameters. layers = spec.neuralNetwork.layers layer_0 = layers[0] self.assertIsNotNone(layer_0.biDirectionalLSTM) self.assertEquals(len(layer_0.input), 5) self.assertEquals(len(layer_0.output), 5)
def test_bidir(self): """ Test the conversion of a bidirectional layer """ from keras.layers import LSTM from keras.layers.wrappers import Bidirectional # Create a simple Keras model model = Sequential() model.add(Bidirectional(LSTM(32, input_shape=(10, 32)), input_shape=(10, 32))) input_names = ['input'] output_names = ['output'] spec = keras.convert(model, input_names, output_names).get_spec() self.assertIsNotNone(spec) # Test the model class self.assertIsNotNone(spec.description) self.assertTrue(spec.HasField('neuralNetwork')) # Test the inputs and outputs self.assertEquals(len(spec.description.input), len(input_names) + 4) self.assertEquals(input_names[0], spec.description.input[0].name) self.assertEquals(32, spec.description.input[1].type.multiArrayType.shape[0]) self.assertEquals(32, spec.description.input[2].type.multiArrayType.shape[0]) self.assertEquals(32, spec.description.input[3].type.multiArrayType.shape[0]) self.assertEquals(32, spec.description.input[4].type.multiArrayType.shape[0]) self.assertEquals(len(spec.description.output), len(output_names) + 4) self.assertEquals(output_names[0], spec.description.output[0].name) self.assertEquals(64, spec.description.output[0].type.multiArrayType.shape[0]) self.assertEquals(32, spec.description.output[1].type.multiArrayType.shape[0]) self.assertEquals(32, spec.description.output[2].type.multiArrayType.shape[0]) self.assertEquals(32, spec.description.output[3].type.multiArrayType.shape[0]) self.assertEquals(32, spec.description.output[4].type.multiArrayType.shape[0]) # Test the layer parameters. layers = spec.neuralNetwork.layers layer_0 = layers[0] self.assertIsNotNone(layer_0.biDirectionalLSTM) self.assertEquals(len(layer_0.input), 5) self.assertEquals(len(layer_0.output), 5)
def SiameseLSTM(max_token_length, hidden_size, embedding_size=300): text_input_1 = Input(shape=(max_token_length, embedding_size), name='text_1') text_mask_1 = Masking(mask_value=0.0, name='text_mask_1')(text_input_1) # text_dropout_1 = Dropout(.5, name='text_dropout_1')(text_mask_1) text_input_2 = Input(shape=(max_token_length, embedding_size), name='text_2') text_mask_2 = Masking(mask_value=0.0, name='text_mask_2')(text_input_2) # text_dropout_2 = Dropout(.5, name='text_dropout_2')(text_mask_2) lstm_1_a = Bidirectional(GRU(units=hidden_size, return_sequences=True, name='RNN_1_a'))(text_mask_1) lstm_1_b = Bidirectional(GRU(units=hidden_size, return_sequences=False, name='RNN_1_b'))(lstm_1_a) """ lstm_1_c = Bidirectional(GRU(units=hidden_size, return_sequences=False, name='RNN_1_c'))(lstm_1_b) """ lstm_2_a = Bidirectional(GRU(units=hidden_size, return_sequences=True, name='RNN_2_a'))(text_mask_2) lstm_2_b = Bidirectional(GRU(units=hidden_size, return_sequences=False, name='RNN_2_b'))(lstm_2_a) """ lstm_2_c = Bidirectional(GRU(units=hidden_size, return_sequences=False, name='RNN_2_c'))(lstm_2_b) """ cosine_similarity = Dot(axes=1, normalize=True, name='cosine_similarity')([lstm_1_b, lstm_2_b]) model = Model(inputs=[text_input_1, text_input_2], outputs=cosine_similarity) return model
