def loadModel(): global model, sentiment_tag, maxLength metaData = __loadStuff("meta_sentiment_chinese.p") maxLength = metaData.get("maxLength") vocab_size = metaData.get("vocab_size") output_dimen = metaData.get("output_dimen") embedding_dim = 512 if model is None: model = Sequential() model.add(Embedding(vocab_size, embedding_dim, input_length=maxLength)) # Each input would have a size of (maxLength x 256) and each of these 256 sized vectors are fed into the GRU layer one at a time. # All the intermediate outputs are collected and then passed on to the second GRU layer. model.add(GRU(256, dropout=0.9, return_sequences=True)) # Using the intermediate outputs, we pass them to another GRU layer and collect the final output only this time model.add(GRU(64, dropout=0.9)) # The output is then sent to a fully connected layer that would give us our final output_dim classes # model.add(Dense(output_dimen, activation='softmax')) model.add(Dense(output_dimen, activation='sigmoid')) # We use the adam optimizer instead of standard SGD since it converges much faster print('*'*100) model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy']) model.load_weights('sentiment_chinese_model.HDF5') model.summary() print("Model weights loaded!")
def create_GRU_model(timesteps, learning_rate,num_hidden_layers, num_lstm_nodes,dropout_rate,approach): """ Hyper-parameters: learning_rate: Learning-rate for the optimizer. num_lstm_nodes: Number of lstm nodes dropout_rate: Drop-out value num_hidden_layers: Number of hidden layers """ model = Sequential() if approach == 63: if num_hidden_layers == 1: model.add(Bidirectional(LSTM(units = num_lstm_nodes, return_sequences = False, input_shape = (timesteps, 1)))) elif num_hidden_layers == 2: model.add(Bidirectional(LSTM(units = num_lstm_nodes, return_sequences = True, input_shape = (timesteps, 1)))) model.add(Dropout(dropout_rate)) model.add(Bidirectional(LSTM(units = num_lstm_nodes, return_sequences = False))) elif num_hidden_layers == 3: model.add(Bidirectional(LSTM(units = num_lstm_nodes, return_sequences = True, input_shape = (timesteps, 1)))) model.add(Dropout(dropout_rate)) model.add(Bidirectional(LSTM(units = num_lstm_nodes, return_sequences = True))) model.add(Dropout(dropout_rate)) model.add(Bidirectional(LSTM(units = num_lstm_nodes, return_sequences = False))) else: if num_hidden_layers == 1: model.add(GRU(units = num_lstm_nodes, return_sequences = False, input_shape = (timesteps, 5))) elif num_hidden_layers == 2: model.add(GRU(units = num_lstm_nodes, return_sequences = True, input_shape = (timesteps, 5))) model.add(Dropout(dropout_rate)) model.add(GRU(units = num_lstm_nodes, return_sequences = False)) elif num_hidden_layers == 3: model.add(GRU(units = num_lstm_nodes, return_sequences = True, input_shape = (timesteps, 5))) model.add(Dropout(dropout_rate)) model.add(GRU(units = num_lstm_nodes, return_sequences = True)) model.add(Dropout(dropout_rate)) model.add(GRU(units = num_lstm_nodes, return_sequences = False)) model.add(Dropout(dropout_rate)) model.add(Dense(units = 1)) if (approach == 240) | (approach ==31): model.add(Activation('sigmoid')) model.compile(optimizer = RMSprop(lr=learning_rate, clipvalue=0.5), loss = 'binary_crossentropy', metrics=['acc','binary_crossentropy',tf.keras.metrics.AUC(name='auc')]) elif (approach == 63) | (approach == 241): model.add(Activation('linear')) model.compile(optimizer = Adam(lr=learning_rate, clipvalue=0.5), loss = 'mean_squared_error', metrics=[tf.keras.metrics.RootMeanSquaredError(name='RMSE'), 'mean_squared_error', tf.keras.metrics.MeanAbsoluteError(name='MAE', dtype=None)]) return model
def _createModel(self, batch_size): model = Sequential() model.add( Embedding(self.vocab_size, self.hparams['embed_dim'], batch_input_shape=[batch_size, None])) model.add( GRU(self.hparams['rnn_neurons'], return_sequences=True, stateful=True, recurrent_initializer='glorot_uniform', dropout=self.hparams['dropout'])) model.add( GRU(self.hparams['rnn_neurons'], return_sequences=True, stateful=True, recurrent_initializer='glorot_uniform', dropout=self.hparams['dropout'])) model.add(Dense(self.vocab_size)) opt = tf.keras.optimizers.Adam( learning_rate=self.hparams['learning_rate']) model.compile(optimizer=opt, loss=self._sparse_cat_loss) self.model = model
def build_RNN_model(self): inputs = Input(shape=(self.state_length, self.features)) # h1 = GRU(32, activation='relu', kernel_initializer=he_normal(seed=215247), return_sequences=True)(inputs) # h2 = GRU(256, activation='relu', kernel_initializer=he_normal(seed=87), return_sequences=True)(inputs) h3 = GRU(64, activation='relu', kernel_initializer=he_normal(seed=56))(inputs) h4 = Dense(64, activation='relu', kernel_initializer=he_normal(seed=524))(h3) # h4 = Dense(256, activation='relu', kernel_initializer=he_normal(seed=217))(h4) # h4 = Dense(128, activation='relu', kernel_initializer=he_normal(seed=217))(h4) h4 = Dense(64, activation='relu', kernel_initializer=he_normal(seed=50))(h4) # h4 = Dense(32, activation='relu', kernel_initializer=he_normal(seed=527))(h4) # h4 = Dense(16, activation='relu', kernel_initializer=he_normal(seed=9005247))(h4) outputs = Dense(self.n_actions*self.n_nodes, kernel_initializer=he_normal(seed=89))(h4) model = Model(inputs=inputs, outputs=outputs) model.compile(loss='mse', optimizer='rmsprop') return model
def bigru1(n_units) -> Sequential: """ Encoder with 1 Bidirectional LSTM Layer. Parameters ---------- n_units : int Number of units for the LSTM layer. Returns ------- Sequential """ model = Sequential(name='single_bi_gru_encoder') model.add(Bidirectional(GRU(units=n_units))) return model
def compile_lstm_gru(max_char, chars): model = Sequential() model.add( LSTM(256, input_shape=(max_char, len(chars)), recurrent_dropout=0.2, return_sequences=True, activation='tanh')) model.add(GRU(128, recurrent_dropout=0.2, return_sequences=True)) model.add(Dropout(0.4)) model.add(Dense(len(chars), activation='softmax')) model.compile(loss='categorical_crossentropy', optimizer='adam') return model
def residual_block( x, units, conv_num=3, activation='tanh'): # ( input, output node, for 문 반복 횟수, activation ) # Shortcut s = GRU(units, return_sequences=True)(x) for i in range(conv_num - 1): x = LSTM(units, return_sequences=True)( x ) # return_sequences=True 이거 사용해서 lstm shape 부분 3차원으로 맞춰줌 -> 자세한 내용 찾아봐야함 x = Activation(activation)(x) x = LSTM(units)(x) x = Add()([x, s]) return Activation(activation)(x)
def LabelEncoder(self, inputs, encoder, dropout_rate, hidden_units_size): # Apply variational drop-out + Mask input to exclude paddings inner_inputs = SpatialDropout1D(dropout_rate)(inputs) if encoder == 'cnns': inner_inputs = Conv1D(filters=hidden_units_size, kernel_size=3, strides=1, padding="same")(inner_inputs) inner_inputs = Camouflage(mask_value=0)( inputs=[inner_inputs, inputs]) outputs = GlobalMaxPooling1D()(inner_inputs) elif encoder == 'grus': if self._cuDNN: outputs = GRU(units=hidden_units_size)(inner_inputs) else: outputs = GRU(units=hidden_units_size, activation="tanh", recurrent_activation='sigmoid')(inner_inputs) elif encoder == 'average+': inner_inputs = SymmetricMasking(mask_value=0.0)( [inner_inputs, inputs]) inner_inputs = GlobalMeanPooling1D()(inner_inputs) outputs = Dense(units=hidden_units_size)(inner_inputs) elif encoder == 'average': inner_inputs = SymmetricMasking(mask_value=0.0)( [inner_inputs, inputs]) outputs = GlobalMeanPooling1D()(inner_inputs) elif encoder == 'bert': inner_inputs = BERT(output_representation='sequence_output', trainable=False)(inputs) outputs = Camouflage(mask_value=0)(inputs=[inner_inputs, inputs]) return outputs
def gru1(n_units) -> Sequential: """ Simple encoder with just one GRU layer. Parameters ---------- n_units : int Number of units for the GRU layer. Returns ------- Sequential """ model = Sequential(name='single_gru_encoder') model.add(GRU(units=n_units)) return model
def GRUNN(ANNSetup, test, train, VarList): #TODO: revise this! assert 0 == 1 model = Sequential() GRUNeurons = ANNSetup.Neurons[0] DenseNeurons = ANNSetup.Neurons[1] for i in range(len(GRUNeurons)): print(GRUNeurons[i]) if(i == len(GRUNeurons)-1): model.add(GRU(GRUNeurons[i],activation='tanh', recurrent_activation='sigmoid')) #,dropout=ANNSetup.Dropout[i] else: model.add(GRU(GRUNeurons[i],activation='tanh', recurrent_activation='sigmoid', return_sequences=True)) for j in range(len(DenseNeurons)): model.add(Dense(DenseNeurons[j], activation='relu')) Opti = GetOpti(ANNSetup.Optimizer,ANNSetup.LearnRate) model.compile(optimizer=Opti, loss='binary_crossentropy', metrics=['accuracy']) model.fit(train.Events,train.OutTrue, sample_weight=train.Weights, nb_epoch=int(ANNSetup.Epochs), batch_size=int(ANNSetup.Batch), verbose=2) # model.save(ANNSetup.SavePath) # model.summary() return model
def __init__(self, units, vocab_size, Embedding_dims): super(LocalAttentionDecoder, self).__init__() self.units = units self.Embedding = Embedding(vocab_size, Embedding_dims) self.GRU = GRU(self.units, return_sequences=True, return_state=True, recurrent_initializer='glorot_uniform') self.fc1 = Dense(self.units) self.Dropout = Dropout(0.5) self.BN = BatchNormalization() self.fc2 = Dense(vocab_size) self.W1 = Dense(units) self.W2 = Dense(units) self.V = Dense(1)
def gru(self): """Build a simple GRU network. We pass the extracted features from our CNN to this model predomenently.""" # Model. model = Sequential() model.add( GRU(2048, return_sequences=False, input_shape=self.input_shape, dropout=0.5)) model.add(Dense(512, activation='relu')) model.add(Dropout(0.5)) model.add(Dense(self.nb_classes, activation='softmax')) return model
def loader(input_shape, num_outputs, output_activation="log_softmax", channel_dropout_rate=0): inputs = Input(shape=input_shape, name="input") x = inputs if channel_dropout_rate > 0: x = SpatialDropout1D( channel_dropout_rate, name="channel_dropout_{:.2f}".format(channel_dropout_rate))(x) x = Bidirectional(GRU(512, return_sequences=True), merge_mode="concat", name="BGRU_1")(x) x = Bidirectional(GRU(512), merge_mode="concat", name="BGRU_2")(x) x = BatchNormalization(name="BGRU_2_bn")(x) x = Dense(1024, activation="relu", name="fc_relu_1")(x) x = BatchNormalization(name="fc_relu_1_bn")(x) x = Dense(1024, activation="relu", name="fc_relu_2")(x) x = BatchNormalization(name="fc_relu_2_bn")(x) outputs = Dense(num_outputs, activation=None, name="output")(x) if output_activation: outputs = Activation(getattr(tf.nn, output_activation), name=str(output_activation))(outputs) return Model(inputs=inputs, outputs=outputs, name="BGRU")
def model(input_shape): """ Function creating the model's graph in Keras. Argument: input_shape -- shape of the model's input data (using Keras conventions) Returns: model -- Keras model instance """ X_input = Input(shape = input_shape) # conv_1 = Conv3D(filters=32, kernel_size=(1, 1, 1), padding="same", strides=(1, 1, 1), activation="elu")(X_input) # conv_2 = Conv3D(filters=64, kernel_size=(1, 1, 1), padding="same", strides=(1, 1, 1), activation="elu")(conv_1) # conv_3 = Conv3D(filters=128, kernel_size=(1, 1, 1), padding="same", strides=(1, 1, 1), activation="elu")(conv_2) conv_3 = Conv3D(filters=128, kernel_size=(1, 3, 3), padding="same", strides=(1, 1, 1), activation="elu")(X_input) shape = conv_3.get_shape().as_list() pool_2_flat = Reshape([shape[1], shape[2]*shape[3]*shape[4]])(conv_3) fc = Dense(1024, activation="elu")(pool_2_flat) fc_drop = Dropout(dropout_prob)(fc) lstm_in = Reshape([10, 1024])(fc_drop) # lstm_1 = LSTM(units=1024, return_sequences=True, unit_forget_bias=True, dropout=dropout_prob)(lstm_in) # rnn_output = LSTM(units=1024, return_sequences=False, unit_forget_bias=True)(lstm_1) # lstm_1 = GRU(units=1024, return_sequences=True, dropout=dropout_prob)(lstm_in) rnn_output = GRU(units=1024, return_sequences=False)(lstm_in) shape_rnn_out = rnn_output.get_shape().as_list() fc_out = Dense(shape_rnn_out[1], activation="elu")(rnn_output) fc_drop = Dropout(dropout_prob)(fc_out) y_ = Dense(n_labels)(fc_drop) y_posi = Softmax()(y_) model = Model(inputs = X_input, outputs = y_posi) return model
def __init__(self, hidden_size=1024, max_sequence_len=40, batch_size=batch_size, embedding_dim=300, vocab_size=vocab_size + 1): super(Encoder, self).__init__() self.embedding_dim = embedding_dim self.vocab_size = vocab_size self.max_sequence_len = max_sequence_len self.hidden_size = hidden_size self.batch_size = batch_size self.embedding_layer = Embedding(input_dim=self.vocab_size, output_dim=self.embedding_dim, weights=[embeddings_matrix], trainable=False) self.GRU_1 = GRU(units=hidden_size, return_sequences=True, recurrent_initializer='glorot_uniform') self.GRU_2 = GRU(units=hidden_size, return_sequences=True, return_state=True, recurrent_initializer='glorot_uniform')
def han_model(): model = Sequential() model.add(Embedding(vocab_size, word_dim, mask_zero=True, input_length=max_input_len)) model.add(Bidirectional(GRU(16, activation='tanh', return_sequences=True))) model.add(HierarchicalAttention(50)) model.add(Dense(n_class, activation='softmax')) # 配置优化器和损失函数 rmsp = optimizers.RMSprop(lr=0.01) model.compile(optimizer=rmsp, loss='categorical_crossentropy', metrics=['accuracy', Precision, Recall]) model.summary() return model
def test(): inputs = Input(shape=(None, ), dtype='int32') output = Embedding(100, 40, trainable=True, mask_zero=False)(inputs) output = Bidirectional(GRU(64, return_sequences=True))(output) output = Dense(9, activation=None)(output) crf = CRF(dtype='float32') output = crf(output) model = Model(inputs, output) model.compile(loss=crf.loss, optimizer='adam', metrics=[crf.accuracy]) x = [[5, 2, 3] * 3] * 10 y = [[1, 2, 3] * 3] * 10 model.fit(x=x, y=y, epochs=10, batch_size=4) model.save('model')
def combSedV1(self): input_combine = tf.keras.Input(shape=self.input_shape) x = tf.keras.layers.Conv1D(name='conv1D', filters=256, kernel_size=7, strides=1, padding='same')(input_combine) x = BatchNormalization(name='bn', center=True, scale=True, trainable=True)(x) x = tf.keras.activations.relu(x) x = Bidirectional(GRU(units=64, return_sequences=True), name='BiDirection')(x) x = SelfAttention(attention_size=64)(x) x = Dense(14, activation='sigmoid')(x) model = tf.keras.Model( inputs=input_combine, outputs=x, name='Combined_model_sed_v1' ) return model
def HanModel(n_classes, len_word_index, embedding_matrix, MAX_SENTENCE_NUM=40, MAX_WORD_NUM=50, EMBED_SIZE=100): # Word Encoder word_input = Input(shape=(MAX_WORD_NUM,), dtype='int32', name='word_input') word_sequences = Embedding(len_word_index + 1, EMBED_SIZE, weights=[embedding_matrix], input_length=MAX_WORD_NUM, trainable=True, name='word_embedding')(word_input) emb_drop = Dropout(rate=0.2, name='word_dropout')(word_sequences) word_gru = Bidirectional(GRU((int)(EMBED_SIZE / 2), return_sequences=True, bias_regularizer=regularizers.l2(0.01), kernel_regularizer=regularizers.l2(0.01), recurrent_regularizer=regularizers.l2(0.01)), name='word_gru')(emb_drop) word_dense = Dense(EMBED_SIZE, activation='relu', name='word_dense')(word_gru) word_att, word_coeff = AttentionLayer(EMBED_SIZE, return_coefficients=True, name='word_attention')(word_dense) word_encoder = Model(inputs=word_input, outputs=word_att, name='WordEncoder') print(word_encoder.summary()) # Sentence Attention model sent_input = Input(shape=(MAX_SENTENCE_NUM, MAX_WORD_NUM), dtype='int32', name='sent_input') sent_encoder = TimeDistributed(word_encoder, name='sent_linking')(sent_input) sent_gru = Bidirectional(GRU((int)(EMBED_SIZE / 2), return_sequences=True, bias_regularizer=regularizers.l2(0.01), kernel_regularizer=regularizers.l2(0.01), recurrent_regularizer=regularizers.l2(0.01)), name='sent_gru')(sent_encoder) sent_dense = Dense(EMBED_SIZE, activation='relu', name='sent_dense')(sent_gru) sent_att, sent_coeff = AttentionLayer(EMBED_SIZE, return_coefficients=True, name='sent_attention')(sent_dense) sent_drop = Dropout(rate=0.5, name='sent_dropout')(sent_att) preds = Dense(n_classes, activation='softmax', name='output')(sent_drop) return Model(sent_input, preds, name='HanModel')
def generate_model(vocab: set, seq_len: int, rnn_units=50, learning_rate=0.001, embedding=False, embedding_dim=256) -> tf.keras.Model: """ TODO write doc for model generation :param embedding_dim: :param embedding: :param learning_rate: :param vocab: :param seq_len: :param rnn_units: :return: """ model = Sequential() optimizer = Adam(lr=learning_rate) if embedding: # if embedding layer need to add first LSTM layer without input shape declared model.add( Embedding(len(vocab), embedding_dim, trainable=True, embeddings_initializer=None)) model.add( LSTM(rnn_units, return_sequences=True, dropout=0.15, recurrent_dropout=0.15, recurrent_initializer='glorot_uniform')) else: # if no embedding layer need to declare inputs in first layer model.add( LSTM(rnn_units, input_shape=(seq_len + 1, len(vocab)), return_sequences=True, dropout=0.15, recurrent_dropout=0.15, recurrent_initializer='glorot_uniform')) model.add( GRU(rnn_units, return_sequences=False, dropout=0.15, recurrent_dropout=0.15, recurrent_initializer='glorot_uniform')) model.add(Dense(len(vocab), activation='softmax')) model.compile(loss='categorical_crossentropy', optimizer=optimizer) print(model.summary()) return model
def build(self, Name="DeepSpeech2", num_conv=3, num_rnn=7, beam_width=50): self.model = Sequential(name=Name) # self.model.add(Input(shape = self.input_shape)) # Conv Layers self.model.add( Conv2D(filters=16, kernel_size=(3, 3), strides=3, padding='same', input_shape=self.input_shape, name=f"Conv1")) for i in range(1, num_conv): self.model.add( Conv2D(filters=16, kernel_size=(3, 3), strides=3, padding='same', name=f"Conv{i+1}")) # Conv2RNN self.model.add(Reshape((self.input_shape[-1], 16))) # RNN Layers for i in range(num_rnn): self.model.add( Bidirectional(GRU(units=800, return_sequences=True), name=f"RNN{i+1}")), self.model.add(SeqWiseBatchNorm(name=f"BatchNorm{i+1}")) # Beam Search Layer : For later implementations, requires a monodir rnn cell # self.model.add(BeamSearchDecoder( # cell = self.model.get_layer(name = f"RNN{i+1}"), # beam_width = beam_width, # output_layer = Dense(800) # )) # Final Layer self.model.add( TimeDistributed(Dense(units=ALPHABET_LENGTH, activation='softmax'), name="OutputLayer")) try: return self.model except: print("Couldn't build the model") return
def build_RNN_model(self): with tf.variable_scope("intentNet", reuse=tf.AUTO_REUSE): cam = TimeDistributed(Dense(512, activation='relu', kernel_regularizer=l2(1e-5), \ bias_regularizer=l2(1e-5), name='cam_fc'))(self.input_cam) out = GRU( self.units, dropout=0.1, recurrent_dropout=0.1, activation='relu', kernel_regularizer=l2(1e-5), bias_regularizer=l2(1e-5), name='intentNet_gru')(cam, training=self.is_train) out = Dropout(0.1)(out, training=self.is_train) # record softmax and data (aleatoric) uncertainty for the output softmax_multi_forecast = [] datavar_multi_forecast = [] # the list of loss loss_list = [] for m in range(self.num_pred): logits = Dense(self.n_classes, activation='linear', kernel_regularizer=l2(1e-5), \ bias_regularizer=l2(1e-5), name='intentNet_logits_%d' % m)(out) out_prob = tf.nn.softmax(logits, axis=-1) datavar = Dense(1, activation='softplus', kernel_regularizer=l2(1e-5), \ bias_regularizer=l2(1e-5), name='intentNet_var_%d' % m)(out) loss = self.bayesian_loss(logits=logits, labels=self.labels[:,m,:], datavar=datavar) loss_list.append(loss) datavar_multi_forecast.append(datavar) softmax_multi_forecast.append(out_prob) self.pred_datavar = tf.stack(datavar_multi_forecast, axis=1) self.pred_softmax = tf.stack(softmax_multi_forecast, axis=1) with tf.variable_scope("intentNet_train", reuse=tf.AUTO_REUSE): self.intent_loss = tf.stack(loss_list, axis=1) self.avg_loss = tf.reduce_mean(self.intent_loss) intent_vars = tf.trainable_variables("intentNet") intent_gradients = self.opt_intentNet.compute_gradients(self.avg_loss, intent_vars) self.train_op_intentNet = self.opt_intentNet.apply_gradients(intent_gradients, self.global_step) return
def __init__(self): super(MineGRU, self).__init__() self.c1 = Conv2D(32, (5, 5)) self.p1 = MaxPooling2D((2, 2), strides=1) self.a1 = Activation('relu') self.c2 = Conv2D(32, (5, 5)) self.p2 = AveragePooling2D((2, 2), strides=1) self.a2 = Activation('relu') self.f1 = Flatten() self.d1 = Dense(128) self.R1 = RepeatVector(7) self.B1 = Bidirectional(GRU(128, return_sequences=True)) self.T1 = TimeDistributed(Dense(65)) self.a3 = Activation('softmax')
def make_net(model, n_layers, hidden_units, output_units, net_type='GRU'): if net_type == 'GRU': for i in range(n_layers): model.add( GRU(units=hidden_units, return_sequences=True, name=f'GRU_{i + 1}')) else: for i in range(n_layers): model.add( LSTM(units=hidden_units, return_sequences=True, name=f'LSTM_{i + 1}')) model.add(Dense(units=output_units, activation='sigmoid', name='OUT')) return model
def create_actor_model(self): # ========================================================================= # state_input = Input(shape=(None,self.obs_dim)) act_hist_input = Input(shape=(None,self.act_dim)) mask_state_input = Masking(mask_value=0.)(state_input) mask_action_input = Masking(mask_value=0.)(act_hist_input) obs_h1 = Dense(256, activation='relu')(mask_state_input) act_h1 = Dense(256, activation='relu')(mask_action_input) actor_rnn,state_h = GRU(256, return_state=True)(Concatenate()([obs_h1,act_h1])) h2 = Dense(500, activation='relu')(state_h) output = Dense(self.act_dim, activation='tanh')(h2) model = Model([state_input,act_hist_input], output) adam = Adam(lr=0.0001) model.compile(loss="mse", optimizer=adam) return state_input, act_hist_input, model
def build_model(input_shape, num_classes): inputs = Input(shape=input_shape, name='input') x = residual_block(inputs, 1024, 2) x = residual_block(x, 512, 2) x = residual_block(x, 512, 3) x = residual_block(x, 256, 3) x = residual_block(x, 256, 3) x = Bidirectional(GRU(16))(x) # LSTM 레이어 부분에 Bidirectional() 함수 -> many to one 유형 x = Dense(256, activation="tanh")(x) x = Dense(128, activation="tanh")(x) outputs = Dense(num_classes, activation='softmax', name="output")(x) return Model(inputs=inputs, outputs=outputs)
def post_process_CBHG(input_data, K_CBHG): t = conv1dbank(K_CBHG, input_data) t = MaxPooling1D(pool_size=2, strides=1, padding='same')(t) t = Conv1D(filters=256, kernel_size=3, strides=1, padding='same')(t) t = BatchNormalization()(t) t = Activation('relu')(t) t = Conv1D(filters=80, kernel_size=3, strides=1, padding='same')(t) t = BatchNormalization()(t) residual = Add()([input_data, t]) highway_net = get_highway_output(residual, 4, activation='relu') CBHG_encoder = Bidirectional(GRU(128))(highway_net) return CBHG_encoder
def __init__(self, vocab_size, embedding_dim, decoder_units, batch_size): super(Decoder, self).__init__() self.batch_size = batch_size self.vocab_size = vocab_size self.decoder_units = decoder_units self.embedding = Embedding(vocab_size, embedding_dim, weights=[embeddings_matrix], trainable=False) self.gru = GRU(self.decoder_units, return_sequences=True, return_state=True, recurrent_initializer='glorot_uniform') # self.topic_pred = TopicPrediction(ldaModel = lda_model, num_topics=lda_model.num_topics, dims = 1000) self.FC = Dense(self.vocab_size) self.attention = AttentionLayer(self.decoder_units)
def __init__(self, max_length, is_train, teacher_forcing_rate, hidden_dim, embedding_matrix, dropout_rate=1.0): self.max_length = max_length self.teacher_forcing_rate = teacher_forcing_rate self.is_train = is_train self.dropout = Dropout(dropout_rate) self.embedding_matrix = embedding_matrix self.attention = Additive_attention(num_units=hidden_dim) self.gru = GRU(units=hidden_dim, return_state=True) self.dense = Dense(units=embedding_matrix.shape[0])
def build_a_model(x_shape): x = Input(x_shape) h = conv1d_block(x, 128) h = GRU(units=256)(h) h = dense_block(h, 32) logits = Dense(units=2)(h) y = Activation("softmax")(logits) model = Model( inputs=x, outputs=y) return model