def __init__(self, num_units, use_lstm, encoder_max_sequence_length, decoder_max_sentence_length, feature_size, vocab_size, learning_rate, learning_rate_decay_factor, max_gradient_norm, forward_only=False):
self.feature_size = feature_size
self.vocab_size = vocab_size
self.encoder_max_sequence_length = encoder_max_sequence_length
self.decoder_max_sentence_length = decoder_max_sentence_length
self.learning_rate = tf.Variable(float(learning_rate), trainable=False, dtype=tf.float32)
self.learning_rate_decay_op = self.learning_rate.assign(self.learning_rate * learning_rate_decay_factor)
self.global_step = tf.Variable(0, trainable=False)
encoder = tf.nn.rnn_cell.GRUCell(num_units)
if use_lstm:
encoder = tf.nn.rnn_cell.BasicLSTMCell(num_units=num_units, state_is_tuple=False)
decoder = tf.nn.rnn_cell.GRUCell(num_units)
if use_lstm:
decoder = tf.nn.rnn_cell.BasicLSTMCell(num_units=num_units, state_is_tuple=False)
decoder = tf.nn.rnn_cell.OutputProjectionWrapper(decoder, vocab_size)
# Feeds for inputs.
self.encoder_inputs = []
self.decoder_inputs = []
self.target_weights = []
for i in xrange(encoder_max_sequence_length):
self.encoder_inputs.append(tf.placeholder(tf.float32, shape=[None, feature_size], name="encoder{0}".format(i)))
for i in xrange(decoder_max_sentence_length):
self.decoder_inputs.append(tf.placeholder(tf.int32, shape=[None], name="decoder{0}".format(i)))
self.target_weights.append(tf.placeholder(tf.float32, shape=[None], name="weight{0}".format(i)))
self.targets = [self.decoder_inputs[i + 1] for i in xrange(len(self.decoder_inputs) -1)]
self.targets.append(tf.placeholder(tf.int32, shape=[None], name="last_target"))
with variable_scope.variable_scope("embedding_rnn_seq2seq") as scope:
encoder_outputs, self.encoder_state = rnn.rnn(cell=encoder, inputs=self.encoder_inputs, dtype=tf.float32)
if forward_only:
self.outputs, self.decoder_states = embedding_rnn_decoder(self.decoder_inputs, self.encoder_state, decoder, vocab_size, num_units, feed_previous=True, update_embedding_for_previous=False)
else:
self.outputs, self.decoder_states = embedding_rnn_decoder(self.decoder_inputs, self.encoder_state, decoder, vocab_size, num_units, feed_previous=False)
# Training outputs and losses.
if not forward_only:
self.loss = tf.nn.seq2seq.sequence_loss(self.outputs, self.targets, self.target_weights)
gradients = tf.gradients(self.loss, tf.trainable_variables())
clipped_gradients, norm = tf.clip_by_global_norm(gradients, max_gradient_norm)
self.update = tf.train.AdamOptimizer(learning_rate=self.learning_rate).apply_gradients(zip(clipped_gradients, tf.trainable_variables()), global_step=self.global_step)
self.saver = tf.train.Saver(tf.all_variables(), max_to_keep=99999999)
def decoder_f(encoder_state, decoder_inputs):
return seq2seq.embedding_rnn_decoder(
decoder_inputs,
encoder_state,
cell,
embedding=self.dec_embedding,
word_dropout_keep_prob=word_dropout_keep_prob,
replace_input=replace_input,
num_symbols=target_vocab_size,
embedding_size=size,
output_projection=output_projection,
feed_previous=feed_previous,
weight_initializer=weight_initializer)