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
