def inference(self, X, reuse=None, trainMode=True):
word_vectors = tf.nn.embedding_lookup(self.words, X)
length = self.length(X)
length_64 = tf.cast(length, tf.int64)
reuse = None if trainMode else True
if FLAGS.embedding_size_2 > 0:
word_vectors2 = tf.nn.embedding_lookup(self.words2, X)
word_vectors = tf.concat(2, [word_vectors, word_vectors2])
#if trainMode:
# word_vectors = tf.nn.dropout(word_vectors, 0.5)
with tf.variable_scope("rnn_fwbw", reuse=reuse) as scope:
forward_output, _ = tf.nn.dynamic_rnn(
tf.contrib.rnn.LSTMCell(self.numHidden,
reuse=reuse),
word_vectors,
dtype=tf.float32,
sequence_length=length,
scope="RNN_forward")
backward_output_, _ = tf.nn.dynamic_rnn(
tf.contrib.rnn.LSTMCell(self.numHidden,
reuse=reuse),
inputs=tf.reverse_sequence(word_vectors,
length_64,
seq_dim=1),
dtype=tf.float32,
sequence_length=length,
scope="RNN_backword")
backward_output = tf.reverse_sequence(backward_output_,
length_64,
seq_dim=1)
output = tf.concat([forward_output, backward_output], 2)
output = tf.reshape(output, [-1, self.numHidden * 2])
if trainMode:
output = tf.nn.dropout(output, 0.5)
matricized_unary_scores = tf.matmul(output, self.W) + self.b
# matricized_unary_scores = tf.nn.log_softmax(matricized_unary_scores)
unary_scores = tf.reshape(
matricized_unary_scores,
[-1, FLAGS.max_sentence_len, self.distinctTagNum])
return unary_scores, length
python类reverse_sequence()的实例源码
def deep_birnn(hps, inputs, sequence_length, num_layers=1):
"""Efficient deep bidirectional rnn.
Args:
hps: bag of hyperparameters.
inputs: [batch, steps, units] tensor of input embeddings for RNN.
sequence_length: number of steps for each inputs.
num_layers: depth of RNN.
Returns:
Outputs of RNN.
"""
sequence_length = sequence_length
sequence_length_mask = tf.expand_dims(
create_mask(sequence_length, hps.num_art_steps), 2)
for j in xrange(num_layers):
with tf.variable_scope("birnn_fwd_%d" % j):
w = tf.get_variable(
"w", [hps.word_embedding_size + hps.hidden_size, 4 * hps.hidden_size])
b = tf.get_variable("b", [4 * hps.hidden_size])
split_inputs = [tf.reshape(t, [hps.batch_size, -1])
for t in tf.split(1, hps.num_art_steps, inputs)]
(_, _, _, _, _, _, h) = block_lstm(
tf.to_int64(hps.num_art_steps), split_inputs, w, b, forget_bias=1.0)
fwd_outs = h
fwd_outs = tf.concat(1, [tf.expand_dims(fwdo, 1) for fwdo in fwd_outs])
fwd_outs *= sequence_length_mask
with tf.variable_scope("birnn_bwd_%d" % j):
w = tf.get_variable(
"w", [hps.word_embedding_size + hps.hidden_size, 4 * hps.hidden_size])
b = tf.get_variable("b", [4 * hps.hidden_size])
if sequence_length is not None:
rev_inputs = tf.reverse_sequence(inputs, tf.to_int64(sequence_length),
1)
else:
rev_inputs = tf.reverse(inputs, 1)
split_rev_inputs = [tf.reshape(t, [hps.batch_size, -1])
for t in tf.split(1, hps.num_art_steps, rev_inputs)]
(_, _, _, _, _, _, h) = block_lstm(
tf.to_int64(hps.num_art_steps),
split_rev_inputs,
w,
b,
forget_bias=1.0)
bwd_outs = h
bwd_outs = tf.concat(1, [tf.expand_dims(bwdo, 1) for bwdo in bwd_outs])
bwd_outs *= sequence_length_mask
if sequence_length is not None:
rev_bwd_outs = tf.reverse_sequence(bwd_outs,
tf.to_int64(sequence_length), 1)
else:
rev_bwd_outs = tf.reverse(bwd_outs, 1)
inputs = tf.concat(2, [fwd_outs, rev_bwd_outs])
return inputs