Python tensorflow.reverse_sequence() Examples
The following are 30
code examples of tensorflow.reverse_sequence().
You can vote up the ones you like or vote down the ones you don't like,
and go to the original project or source file by following the links above each example.
You may also want to check out all available functions/classes of the module
tensorflow
, or try the search function
.
.
Example #1
| Source File: utils.py From DeepPavlov with Apache License 2.0 | 6 votes |
|
def __call__(self, inputs, seq_len, keep_prob=1.0, is_train=None, concat_layers=True):
outputs = [tf.transpose(inputs, [1, 0, 2])]
for layer in range(self.num_layers):
gru_fw, gru_bw = self.grus[layer]
init_fw, init_bw = self.inits[layer]
mask_fw, mask_bw = self.dropout_mask[layer]
with tf.variable_scope('fw_{}'.format(layer), reuse=tf.AUTO_REUSE):
out_fw, _ = gru_fw(outputs[-1] * mask_fw, (init_fw,))
with tf.variable_scope('bw_{}'.format(layer), reuse=tf.AUTO_REUSE):
inputs_bw = tf.reverse_sequence(
outputs[-1] * mask_bw, seq_lengths=seq_len, seq_dim=0, batch_dim=1)
out_bw, _ = gru_bw(inputs_bw, (init_bw,))
out_bw = tf.reverse_sequence(
out_bw, seq_lengths=seq_len, seq_dim=0, batch_dim=1)
outputs.append(tf.concat([out_fw, out_bw], axis=2))
if concat_layers:
res = tf.concat(outputs[1:], axis=2)
else:
res = outputs[-1]
res = tf.transpose(res, [1, 0, 2])
return res
Example #2
| Source File: rnn.py From BERT with Apache License 2.0 | 6 votes |
|
def bw_dynamic_rnn(cell, inputs, sequence_length=None, initial_state=None,
dtype=None, parallel_iterations=None, swap_memory=False,
time_major=False, scope=None):
assert not time_major # TODO : to be implemented later!
flat_inputs = flatten(inputs, 2) # [-1, J, d]
flat_len = None if sequence_length is None else tf.cast(flatten(sequence_length, 0), 'int64')
flat_inputs = tf.reverse(flat_inputs, [1]) if sequence_length is None \
else tf.reverse_sequence(flat_inputs, sequence_length, 1)
flat_outputs, final_state = tf.nn.dynamic_rnn(cell, flat_inputs, sequence_length=flat_len,
initial_state=initial_state, dtype=dtype,
parallel_iterations=parallel_iterations, swap_memory=swap_memory,
time_major=time_major, scope=scope)
flat_outputs = tf.reverse(flat_outputs, [1]) if sequence_length is None \
else tf.reverse_sequence(flat_outputs, sequence_length, 1)
outputs = reconstruct(flat_outputs, inputs, 2)
return outputs, final_state
Example #3
| Source File: func.py From R-Net with MIT License | 6 votes |
|
def __call__(self, inputs, seq_len, keep_prob=1.0, is_train=None, concat_layers=True):
outputs = [inputs]
with tf.variable_scope(self.scope):
for layer in range(self.num_layers):
gru_fw, gru_bw = self.grus[layer]
init_fw, init_bw = self.inits[layer]
mask_fw, mask_bw = self.dropout_mask[layer]
with tf.variable_scope("fw_{}".format(layer)):
out_fw, _ = tf.nn.dynamic_rnn(
gru_fw, outputs[-1] * mask_fw, seq_len, initial_state=init_fw, dtype=tf.float32)
with tf.variable_scope("bw_{}".format(layer)):
inputs_bw = tf.reverse_sequence(
outputs[-1] * mask_bw, seq_lengths=seq_len, seq_dim=1, batch_dim=0)
out_bw, _ = tf.nn.dynamic_rnn(
gru_bw, inputs_bw, seq_len, initial_state=init_bw, dtype=tf.float32)
out_bw = tf.reverse_sequence(
out_bw, seq_lengths=seq_len, seq_dim=1, batch_dim=0)
outputs.append(tf.concat([out_fw, out_bw], axis=2))
if concat_layers:
res = tf.concat(outputs[1:], axis=2)
else:
res = outputs[-1]
return res
Example #4
| Source File: lstm.py From BERT with Apache License 2.0 | 6 votes |
|
def lstm_seq2seq_internal_attention(inputs, targets, hparams, train,
inputs_length, targets_length):
"""LSTM seq2seq model with attention, main step used for training."""
with tf.variable_scope("lstm_seq2seq_attention"):
# Flatten inputs.
inputs = common_layers.flatten4d3d(inputs)
# LSTM encoder.
inputs = tf.reverse_sequence(inputs, inputs_length, seq_axis=1)
encoder_outputs, final_encoder_state = lstm(
inputs, inputs_length, hparams, train, "encoder")
# LSTM decoder with attention.
shifted_targets = common_layers.shift_right(targets)
# Add 1 to account for the padding added to the left from shift_right
targets_length = targets_length + 1
decoder_outputs = lstm_attention_decoder(
common_layers.flatten4d3d(shifted_targets), hparams, train, "decoder",
final_encoder_state, encoder_outputs, inputs_length, targets_length)
return tf.expand_dims(decoder_outputs, axis=2)
Example #5
| Source File: func.py From R-Net with MIT License | 6 votes |
|
def __call__(self, inputs, seq_len, keep_prob=1.0, is_train=None, concat_layers=True):
outputs = [tf.transpose(inputs, [1, 0, 2])]
for layer in range(self.num_layers):
gru_fw, gru_bw = self.grus[layer]
init_fw, init_bw = self.inits[layer]
mask_fw, mask_bw = self.dropout_mask[layer]
with tf.variable_scope("fw_{}".format(layer)):
out_fw, _ = gru_fw(
outputs[-1] * mask_fw, initial_state=(init_fw, ))
with tf.variable_scope("bw_{}".format(layer)):
inputs_bw = tf.reverse_sequence(
outputs[-1] * mask_bw, seq_lengths=seq_len, seq_dim=0, batch_dim=1)
out_bw, _ = gru_bw(inputs_bw, initial_state=(init_bw, ))
out_bw = tf.reverse_sequence(
out_bw, seq_lengths=seq_len, seq_dim=0, batch_dim=1)
outputs.append(tf.concat([out_fw, out_bw], axis=2))
if concat_layers:
res = tf.concat(outputs[1:], axis=2)
else:
res = outputs[-1]
res = tf.transpose(res, [1, 0, 2])
return res
Example #6
| Source File: rnn.py From inferbeddings with MIT License | 6 votes |
|
def bw_dynamic_rnn(cell, inputs, sequence_length=None, initial_state=None,
dtype=None, parallel_iterations=None, swap_memory=False,
time_major=False, scope=None):
assert not time_major # TODO : to be implemented later!
flat_inputs = flatten(inputs, 2) # [-1, J, d]
flat_len = None if sequence_length is None else tf.cast(flatten(sequence_length, 0), 'int64')
flat_inputs = tf.reverse(flat_inputs, 1) if sequence_length is None \
else tf.reverse_sequence(flat_inputs, sequence_length, 1)
flat_outputs, final_state = tf.nn.dynamic_rnn(cell, flat_inputs, sequence_length=flat_len,
initial_state=initial_state, dtype=dtype,
parallel_iterations=parallel_iterations, swap_memory=swap_memory,
time_major=time_major, scope=scope)
flat_outputs = tf.reverse(flat_outputs, 1) if sequence_length is None \
else tf.reverse_sequence(flat_outputs, sequence_length, 1)
outputs = reconstruct(flat_outputs, inputs, 2)
return outputs, final_state
Example #7
| Source File: recurrent.py From Parser-v3 with Apache License 2.0 | 6 votes |
|
def BiRNN(layer, recur_size, seq_lengths, recur_cell=LSTM, bilin=False, **kwargs):
""""""
locations = tf.expand_dims(tf.one_hot(seq_lengths-1, tf.shape(layer)[1]), -1)
with tf.variable_scope('RNN_FW'):
fw_hidden, fw_cell = recur_cell(layer, recur_size, seq_lengths, **kwargs)
rev_layer = tf.reverse_sequence(layer, seq_lengths, batch_axis=0, seq_axis=1)
with tf.variable_scope('RNN_BW'):
bw_hidden, bw_cell = recur_cell(rev_layer, recur_size, seq_lengths, **kwargs)
rev_bw_hidden = tf.reverse_sequence(bw_hidden, seq_lengths, batch_axis=0, seq_axis=1)
rev_bw_cell = tf.reverse_sequence(bw_cell, seq_lengths, batch_axis=0, seq_axis=1)
if bilin:
layer = tf.concat([fw_hidden*rev_bw_hidden, fw_hidden, rev_bw_hidden], 2)
else:
layer = tf.concat([fw_hidden, rev_bw_hidden], 2)
if recur_cell == RNN:
final_states = tf.squeeze(tf.matmul(hidden, locations, transpose_a=True), -1)
else:
final_fw_hidden = tf.squeeze(tf.matmul(fw_hidden, locations, transpose_a=True), -1)
final_fw_cell = tf.squeeze(tf.matmul(fw_cell, locations, transpose_a=True), -1)
final_rev_bw_hidden = tf.squeeze(tf.matmul(rev_bw_hidden, locations, transpose_a=True), -1)
final_rev_bw_cell = tf.squeeze(tf.matmul(rev_bw_cell, locations, transpose_a=True), -1)
final_states = tf.concat([final_fw_hidden, final_rev_bw_hidden, final_fw_cell, final_rev_bw_cell], 1)
return layer, final_states
Example #8
| Source File: lstm.py From training_results_v0.5 with Apache License 2.0 | 6 votes |
|
def lstm_seq2seq_internal_attention(inputs, targets, hparams, train,
inputs_length, targets_length):
"""LSTM seq2seq model with attention, main step used for training."""
with tf.variable_scope("lstm_seq2seq_attention"):
# Flatten inputs.
inputs = common_layers.flatten4d3d(inputs)
# LSTM encoder.
inputs = tf.reverse_sequence(inputs, inputs_length, seq_axis=1)
encoder_outputs, final_encoder_state = lstm(
inputs, inputs_length, hparams, train, "encoder")
# LSTM decoder with attention.
shifted_targets = common_layers.shift_right(targets)
# Add 1 to account for the padding added to the left from shift_right
targets_length = targets_length + 1
decoder_outputs = lstm_attention_decoder(
common_layers.flatten4d3d(shifted_targets), hparams, train, "decoder",
final_encoder_state, encoder_outputs, inputs_length, targets_length)
return tf.expand_dims(decoder_outputs, axis=2)
Example #9
| Source File: BeplerModel.py From tape-neurips2019 with MIT License | 6 votes |
|
def transform(self, z_fwd, z_rvs, mask_fwd, mask_rvs, sequence_lengths):
h_fwd = []
h = z_fwd
for layer in self.rnn.layers:
h = layer(h, mask=mask_fwd)
h = self.dropout(h)
h_fwd.append(h)
h_rvs = []
h = z_rvs
for layer in self.rnn.layers:
h = layer(h, mask=mask_rvs)
h = self.dropout(h)
h_rvs.append(
tf.reverse_sequence(h, sequence_lengths - 1, seq_axis=1))
return h_fwd, h_rvs
Example #10
| Source File: BeplerModel.py From tape-neurips2019 with MIT License | 6 votes |
|
def embed_and_split(self, x, sequence_lengths, pad=False):
if pad:
# Add one to each sequence element
if not self._use_pfam_alphabet:
x = x + 1
mask = rk.utils.convert_sequence_length_to_sequence_mask(x, sequence_lengths)
x = x * tf.cast(mask, x.dtype)
x = tf.pad(x, [[0, 0], [1, 1]]) # pad x
sequence_lengths += 2
mask = rk.utils.convert_sequence_length_to_sequence_mask(x, sequence_lengths)
z = self.embed(x)
z_fwd = z[:, :-1]
mask_fwd = mask[:, :-1]
z_rvs = tf.reverse_sequence(z, sequence_lengths, seq_axis=1)[:, :-1]
mask_rvs = tf.reverse_sequence(mask, sequence_lengths, seq_axis=1)[:, :-1]
return z_fwd, z_rvs, mask_fwd, mask_rvs, sequence_lengths
Example #11
| Source File: BidirectionalLSTM.py From tape-neurips2019 with MIT License | 6 votes |
|
def call(self, inputs):
sequence = inputs['primary']
protein_length = inputs['protein_length']
sequence = self.embedding(sequence)
tf.add_to_collection('checkpoints', sequence)
forward_output = self.forward_lstm(sequence)
tf.add_to_collection('checkpoints', forward_output)
reversed_sequence = tf.reverse_sequence(sequence, protein_length, seq_axis=1)
reverse_output = self.reverse_lstm(reversed_sequence)
reverse_output = tf.reverse_sequence(reverse_output, protein_length, seq_axis=1)
tf.add_to_collection('checkpoints', reverse_output)
encoder_output = tf.concat((forward_output, reverse_output), -1)
encoder_output = self.dropout(encoder_output)
inputs['encoder_output'] = encoder_output
return inputs
Example #12
| Source File: nn_func.py From AIchallenger2018_MachineReadingComprehension with MIT License | 6 votes |
|
def __call__(self, inputs, seq_len, keep_prob=1.0, is_train=None, concat_layers=True):
# cudnn GRU需要交换张量的维度，可能是便于计算
outputs = [tf.transpose(inputs, [1, 0, 2])]
for layer in range(self.num_layers):
gru_fw, gru_bw = self.grus[layer]
init_fw, init_bw = self.inits[layer]
mask_fw, mask_bw = self.dropout_mask[layer]
with tf.variable_scope("fw_{}".format(layer)):
out_fw, _ = gru_fw(
outputs[-1] * mask_fw, initial_state=(init_fw, ))
with tf.variable_scope("bw_{}".format(layer)):
inputs_bw = tf.reverse_sequence(
outputs[-1] * mask_bw, seq_lengths=seq_len, seq_dim=0, batch_dim=1)
out_bw, _ = gru_bw(inputs_bw, initial_state=(init_bw, ))
out_bw = tf.reverse_sequence(
out_bw, seq_lengths=seq_len, seq_dim=0, batch_dim=1)
outputs.append(tf.concat([out_fw, out_bw], axis=2))
if concat_layers:
res = tf.concat(outputs[1:], axis=2)
else:
res = outputs[-1]
res = tf.transpose(res, [1, 0, 2])
return res
Example #13
| Source File: nn_func.py From AIchallenger2018_MachineReadingComprehension with MIT License | 6 votes |
|
def __call__(self, inputs, seq_len, keep_prob=1.0, is_train=None, concat_layers=True):
# cudnn GRU需要交换张量的维度，可能是便于计算
outputs = [tf.transpose(inputs, [1, 0, 2])]
with tf.variable_scope(self.scope):
for layer in range(self.num_layers):
gru_fw, gru_bw = self.grus[layer]
init_fw, init_bw = self.inits[layer]
mask_fw, mask_bw = self.dropout_mask[layer]
with tf.variable_scope("fw_{}".format(layer)):
out_fw, _ = gru_fw(
outputs[-1] * mask_fw, initial_state=(init_fw, ))
with tf.variable_scope("bw_{}".format(layer)):
inputs_bw = tf.reverse_sequence(
outputs[-1] * mask_bw, seq_lengths=seq_len, seq_dim=0, batch_dim=1)
out_bw, _ = gru_bw(
inputs_bw, initial_state=(init_bw, ))
out_bw = tf.reverse_sequence(
out_bw, seq_lengths=seq_len, seq_dim=0, batch_dim=1)
outputs.append(tf.concat([out_fw, out_bw], axis=2))
if concat_layers:
res = tf.concat(outputs[1:], axis=2)
else:
res = outputs[-1]
res = tf.transpose(res, [1, 0, 2])
return res
Example #14
| Source File: rnn.py From AmusingPythonCodes with MIT License | 6 votes |
|
def __call__(self, inputs, seq_len, keep_prob=1.0, is_train=None, concat_layers=True):
outputs = [tf.transpose(inputs, [1, 0, 2])]
for layer in range(self.num_layers):
gru_fw, gru_bw = self.grus[layer]
param_fw, param_bw = self.params[layer]
init_fw, init_bw = self.inits[layer]
mask_fw, mask_bw = self.dropout_mask[layer]
with tf.variable_scope("fw"):
out_fw, _ = gru_fw(outputs[-1] * mask_fw, init_fw, param_fw)
with tf.variable_scope("bw"):
inputs_bw = tf.reverse_sequence(
outputs[-1] * mask_bw, seq_lengths=seq_len, seq_dim=0, batch_dim=1)
out_bw, _ = gru_bw(inputs_bw, init_bw, param_bw)
out_bw = tf.reverse_sequence(
out_bw, seq_lengths=seq_len, seq_dim=0, batch_dim=1)
outputs.append(tf.concat([out_fw, out_bw], axis=2))
if concat_layers:
res = tf.concat(outputs[1:], axis=2)
else:
res = outputs[-1]
res = tf.transpose(res, [1, 0, 2])
return res
###### self attention part code
Example #15
| Source File: lstm.py From fine-lm with MIT License | 6 votes |
|
def lstm_seq2seq_internal_attention(inputs, targets, hparams, train):
"""LSTM seq2seq model with attention, main step used for training."""
with tf.variable_scope("lstm_seq2seq_attention"):
# This is a temporary fix for varying-length sequences within in a batch.
# A more complete fix should pass a length tensor from outside so that
# all the lstm variants can use it.
inputs_length = common_layers.length_from_embedding(inputs)
# Flatten inputs.
inputs = common_layers.flatten4d3d(inputs)
# LSTM encoder.
inputs = tf.reverse_sequence(inputs, inputs_length, seq_axis=1)
encoder_outputs, final_encoder_state = lstm(
inputs, inputs_length, hparams, train, "encoder")
# LSTM decoder with attention.
shifted_targets = common_layers.shift_right(targets)
# Add 1 to account for the padding added to the left from shift_right
targets_length = common_layers.length_from_embedding(shifted_targets) + 1
decoder_outputs = lstm_attention_decoder(
common_layers.flatten4d3d(shifted_targets), hparams, train, "decoder",
final_encoder_state, encoder_outputs, inputs_length, targets_length)
return tf.expand_dims(decoder_outputs, axis=2)
Example #16
| Source File: rnn.py From DiSAN with Apache License 2.0 | 6 votes |
|
def bw_dynamic_rnn(cell, inputs, sequence_length=None, initial_state=None,
dtype=None, parallel_iterations=None, swap_memory=False,
time_major=False, scope=None):
assert not time_major # TODO : to be implemented later!
flat_inputs = flatten(inputs, 2) # [-1, J, d]
flat_len = None if sequence_length is None else tf.cast(flatten(sequence_length, 0), 'int64')
flat_inputs = tf.reverse(flat_inputs, 1) if sequence_length is None \
else tf.reverse_sequence(flat_inputs, sequence_length, 1)
flat_outputs, final_state = tf.nn.dynamic_rnn(cell, flat_inputs, sequence_length=flat_len,
initial_state=initial_state, dtype=dtype,
parallel_iterations=parallel_iterations, swap_memory=swap_memory,
time_major=time_major, scope=scope)
flat_outputs = tf.reverse(flat_outputs, 1) if sequence_length is None \
else tf.reverse_sequence(flat_outputs, sequence_length, 1)
outputs = reconstruct(flat_outputs, inputs, 2)
return outputs, final_state
Example #17
| Source File: rnn.py From DiSAN with Apache License 2.0 | 6 votes |
|
def bw_dynamic_rnn(cell, inputs, sequence_length=None, initial_state=None,
dtype=None, parallel_iterations=None, swap_memory=False,
time_major=False, scope=None):
assert not time_major # TODO : to be implemented later!
flat_inputs = flatten(inputs, 2) # [-1, J, d]
flat_len = None if sequence_length is None else tf.cast(flatten(sequence_length, 0), 'int64')
flat_inputs = tf.reverse(flat_inputs, 1) if sequence_length is None \
else tf.reverse_sequence(flat_inputs, sequence_length, 1)
flat_outputs, final_state = tf.nn.dynamic_rnn(cell, flat_inputs, sequence_length=flat_len,
initial_state=initial_state, dtype=dtype,
parallel_iterations=parallel_iterations, swap_memory=swap_memory,
time_major=time_major, scope=scope)
flat_outputs = tf.reverse(flat_outputs, 1) if sequence_length is None \
else tf.reverse_sequence(flat_outputs, sequence_length, 1)
outputs = reconstruct(flat_outputs, inputs, 2)
return outputs, final_state
Example #18
| Source File: rnn.py From convai-bot-1337 with GNU General Public License v3.0 | 6 votes |
|
def bw_dynamic_rnn(cell, inputs, sequence_length=None, initial_state=None,
dtype=None, parallel_iterations=None, swap_memory=False,
time_major=False, scope=None):
assert not time_major # TODO : to be implemented later!
flat_inputs = flatten(inputs, 2) # [-1, J, d]
flat_len = None if sequence_length is None else tf.cast(flatten(sequence_length, 0), 'int64')
flat_inputs = tf.reverse(flat_inputs, 1) if sequence_length is None \
else tf.reverse_sequence(flat_inputs, sequence_length, 1)
flat_outputs, final_state = _dynamic_rnn(cell, flat_inputs, sequence_length=flat_len,
initial_state=initial_state, dtype=dtype,
parallel_iterations=parallel_iterations, swap_memory=swap_memory,
time_major=time_major, scope=scope)
flat_outputs = tf.reverse(flat_outputs, 1) if sequence_length is None \
else tf.reverse_sequence(flat_outputs, sequence_length, 1)
outputs = reconstruct(flat_outputs, inputs, 2)
return outputs, final_state
Example #19
| Source File: rnn.py From Densely-Interactive-Inference-Network with Apache License 2.0 | 6 votes |
|
def bw_dynamic_rnn(cell, inputs, sequence_length=None, initial_state=None,
dtype=None, parallel_iterations=None, swap_memory=False,
time_major=False, scope=None):
assert not time_major # TODO : to be implemented later!
flat_inputs = flatten(inputs, 2) # [-1, J, d]
flat_len = None if sequence_length is None else tf.cast(flatten(sequence_length, 0), 'int64')
flat_inputs = tf.reverse(flat_inputs, 1) if sequence_length is None \
else tf.reverse_sequence(flat_inputs, sequence_length, 1)
flat_outputs, final_state = _dynamic_rnn(cell, flat_inputs, sequence_length=flat_len,
initial_state=initial_state, dtype=dtype,
parallel_iterations=parallel_iterations, swap_memory=swap_memory,
time_major=time_major, scope=scope)
flat_outputs = tf.reverse(flat_outputs, 1) if sequence_length is None \
else tf.reverse_sequence(flat_outputs, sequence_length, 1)
outputs = reconstruct(flat_outputs, inputs, 2)
return outputs, final_state
Example #20
| Source File: recurrent_layers.py From QGforQA with MIT License | 6 votes |
|
def map(self, is_train, x, mask=None):
x = tf.transpose(x, [1, 0, 2])
if self.bidirectional:
with tf.variable_scope("forward"):
fw = self._apply_transposed(is_train, x)[0]
with tf.variable_scope("backward"):
if mask is not None:
bw = self._apply_transposed(is_train, tf.reverse_sequence(x, mask, 0, 1))[0]
bw = tf.reverse_sequence(bw, mask, 0, 1)
else:
bw = self._apply_transposed(is_train, tf.reverse(x, 0))[0]
bw = tf.reverse(bw, 0)
out = tf.concat([fw, bw], axis=2)
else:
out = self._apply_transposed(is_train, x)[0]
out = tf.transpose(out, [1, 0, 2])
if mask is not None:
out *= tf.expand_dims(tf.cast(tf.sequence_mask(mask, tf.shape(out)[1]), tf.float32), 2)
return out
Example #21
| Source File: rnn.py From iss-rnns with Apache License 2.0 | 6 votes |
|
def bw_dynamic_rnn(cell, inputs, sequence_length=None, initial_state=None,
dtype=None, parallel_iterations=None, swap_memory=False,
time_major=False, scope=None):
assert not time_major # TODO : to be implemented later!
flat_inputs = flatten(inputs, 2) # [-1, J, d]
flat_len = None if sequence_length is None else tf.cast(flatten(sequence_length, 0), 'int64')
flat_inputs = tf.reverse(flat_inputs, 1) if sequence_length is None \
else tf.reverse_sequence(flat_inputs, sequence_length, 1)
flat_outputs, final_state = _dynamic_rnn(cell, flat_inputs, sequence_length=flat_len,
initial_state=initial_state, dtype=dtype,
parallel_iterations=parallel_iterations, swap_memory=swap_memory,
time_major=time_major, scope=scope)
flat_outputs = tf.reverse(flat_outputs, 1) if sequence_length is None \
else tf.reverse_sequence(flat_outputs, sequence_length, 1)
outputs = reconstruct(flat_outputs, inputs, 2)
return outputs, final_state
Example #22
| Source File: func.py From EMNLP2018_NLI with GNU General Public License v3.0 | 6 votes |
|
def __call__(self, inputs, seq_len, keep_prob=1.0, is_train=None, concat_layers=True):
outputs = [inputs]
with tf.variable_scope(self.scope):
for layer in range(self.num_layers):
gru_fw, gru_bw = self.grus[layer]
init_fw, init_bw = self.inits[layer]
mask_fw, mask_bw = self.dropout_mask[layer]
with tf.variable_scope("fw_{}".format(layer)):
out_fw, _ = tf.nn.dynamic_rnn(
gru_fw, outputs[-1] * mask_fw, seq_len,
initial_state=init_fw,
dtype=tf.float32)
with tf.variable_scope("bw_{}".format(layer)):
inputs_bw = tf.reverse_sequence(
outputs[-1] * mask_bw, seq_lengths=seq_len, seq_dim=1, batch_dim=0)
out_bw, _ = tf.nn.dynamic_rnn(
gru_bw, inputs_bw, seq_len, initial_state=init_bw, dtype=tf.float32)
out_bw = tf.reverse_sequence(
out_bw, seq_lengths=seq_len, seq_dim=1, batch_dim=0)
outputs.append(tf.concat([out_fw, out_bw], axis=2))
if concat_layers:
res = tf.concat(outputs[1:], axis=2)
else:
res = outputs[-1]
return res
Example #23
| Source File: func.py From AmusingPythonCodes with MIT License | 6 votes |
|
def __call__(self, inputs, seq_len, keep_prob=1.0, s=None, concat_layers=True):
outputs = [inputs]
with tf.variable_scope(self.scope):
for layer in range(self.num_layers):
gru_fw, gru_bw = self.grus[layer]
init_fw, init_bw = self.inits[layer]
mask_fw, mask_bw = self.dropout_mask[layer]
with tf.variable_scope("fw_{}".format(layer)):
out_fw, _ = tf.nn.dynamic_rnn(gru_fw, outputs[-1] * mask_fw, seq_len, initial_state=init_fw,
dtype=tf.float32)
with tf.variable_scope("bw_{}".format(layer)):
inputs_bw = tf.reverse_sequence(outputs[-1] * mask_bw, seq_lengths=seq_len, seq_dim=1, batch_dim=0)
out_bw, _ = tf.nn.dynamic_rnn(gru_bw, inputs_bw, seq_len, initial_state=init_bw, dtype=tf.float32)
out_bw = tf.reverse_sequence(out_bw, seq_lengths=seq_len, seq_dim=1, batch_dim=0)
outputs.append(tf.concat([out_fw, out_bw], axis=2))
if concat_layers:
res = tf.concat(outputs[1:], axis=2)
else:
res = outputs[-1]
return res
Example #24
| Source File: func.py From AmusingPythonCodes with MIT License | 6 votes |
|
def __call__(self, inputs, seq_len, keep_prob=1.0, is_train=None, concat_layers=True):
outputs = [tf.transpose(inputs, [1, 0, 2])]
for layer in range(self.num_layers):
gru_fw, gru_bw = self.grus[layer]
param_fw, param_bw = self.params[layer]
init_fw, init_bw = self.inits[layer]
mask_fw, mask_bw = self.dropout_mask[layer]
with tf.variable_scope("fw"):
out_fw, _ = gru_fw(outputs[-1] * mask_fw, init_fw, param_fw)
with tf.variable_scope("bw"):
inputs_bw = tf.reverse_sequence(outputs[-1] * mask_bw, seq_lengths=seq_len, seq_dim=0, batch_dim=1)
out_bw, _ = gru_bw(inputs_bw, init_bw, param_bw)
out_bw = tf.reverse_sequence(out_bw, seq_lengths=seq_len, seq_dim=0, batch_dim=1)
outputs.append(tf.concat([out_fw, out_bw], axis=2))
if concat_layers:
res = tf.concat(outputs[1:], axis=2)
else:
res = outputs[-1]
res = tf.transpose(res, [1, 0, 2])
return res
Example #25
| Source File: rnn.py From AmusingPythonCodes with MIT License | 6 votes |
|
def bw_dynamic_rnn(cell, inputs, sequence_length=None, initial_state=None,
dtype=None, parallel_iterations=None, swap_memory=False,
time_major=False, scope=None):
assert not time_major # TODO : to be implemented later!
flat_inputs = flatten(inputs, 2) # [-1, J, d]
flat_len = None if sequence_length is None else tf.cast(flatten(sequence_length, 0), 'int64')
flat_inputs = tf.reverse(flat_inputs, 1) if sequence_length is None \
else tf.reverse_sequence(flat_inputs, sequence_length, 1)
flat_outputs, final_state = _dynamic_rnn(cell, flat_inputs, sequence_length=flat_len,
initial_state=initial_state, dtype=dtype,
parallel_iterations=parallel_iterations, swap_memory=swap_memory,
time_major=time_major, scope=scope)
flat_outputs = tf.reverse(flat_outputs, 1) if sequence_length is None \
else tf.reverse_sequence(flat_outputs, sequence_length, 1)
outputs = reconstruct(flat_outputs, inputs, 2)
return outputs, final_state
Example #26
| Source File: recurrent.py From neuralmonkey with BSD 3-Clause "New" or "Revised" License | 5 votes |
|
def rnn_layer(rnn_input: tf.Tensor,
lengths: tf.Tensor,
rnn_spec: RNNSpec) -> Tuple[tf.Tensor, tf.Tensor]:
"""Construct a RNN layer given its inputs and specs.
Arguments:
rnn_inputs: The input sequence to the RNN.
lengths: Lengths of input sequences.
rnn_spec: A valid RNNSpec tuple specifying the network architecture.
add_residual: Add residual connections to the layer output.
"""
if rnn_spec.direction == "bidirectional":
fw_cell = _make_rnn_cell(rnn_spec)
bw_cell = _make_rnn_cell(rnn_spec)
outputs_tup, states_tup = tf.nn.bidirectional_dynamic_rnn(
fw_cell, bw_cell, rnn_input, sequence_length=lengths,
dtype=tf.float32)
outputs = tf.concat(outputs_tup, 2)
if rnn_spec.cell_type == "LSTM":
states_tup = (state.h for state in states_tup)
final_state = tf.concat(list(states_tup), 1)
else:
if rnn_spec.direction == "backward":
rnn_input = tf.reverse_sequence(rnn_input, lengths, seq_axis=1)
cell = _make_rnn_cell(rnn_spec)
outputs, final_state = tf.nn.dynamic_rnn(
cell, rnn_input, sequence_length=lengths, dtype=tf.float32)
if rnn_spec.direction == "backward":
outputs = tf.reverse_sequence(outputs, lengths, seq_axis=1)
if rnn_spec.cell_type == "LSTM":
final_state = final_state.h
return outputs, final_state
Example #27
| Source File: recurrent.py From neuralmonkey with BSD 3-Clause "New" or "Revised" License | 5 votes |
|
def rnn_layer(rnn_input: tf.Tensor,
lengths: tf.Tensor,
rnn_spec: RNNSpec) -> Tuple[tf.Tensor, tf.Tensor]:
"""Construct a RNN layer given its inputs and specs.
Arguments:
rnn_inputs: The input sequence to the RNN.
lengths: Lengths of input sequences.
rnn_spec: A valid RNNSpec tuple specifying the network architecture.
add_residual: Add residual connections to the layer output.
"""
if rnn_spec.direction == "bidirectional":
fw_cell = _make_rnn_cell(rnn_spec)
bw_cell = _make_rnn_cell(rnn_spec)
outputs_tup, states_tup = tf.nn.bidirectional_dynamic_rnn(
fw_cell, bw_cell, rnn_input, sequence_length=lengths,
dtype=tf.float32)
outputs = tf.concat(outputs_tup, 2)
if rnn_spec.cell_type == "LSTM":
states_tup = (state.h for state in states_tup)
final_state = tf.concat(list(states_tup), 1)
else:
if rnn_spec.direction == "backward":
rnn_input = tf.reverse_sequence(rnn_input, lengths, seq_axis=1)
cell = _make_rnn_cell(rnn_spec)
outputs, final_state = tf.nn.dynamic_rnn(
cell, rnn_input, sequence_length=lengths, dtype=tf.float32)
if rnn_spec.direction == "backward":
outputs = tf.reverse_sequence(outputs, lengths, seq_axis=1)
if rnn_spec.cell_type == "LSTM":
final_state = final_state.h
return outputs, final_state
Example #28
| Source File: rnnsearch.py From XMUNMT with BSD 3-Clause "New" or "Revised" License | 5 votes |
|
def _encoder(cell_fw, cell_bw, inputs, sequence_length, dtype=None,
scope=None):
with tf.variable_scope(scope or "encoder",
values=[inputs, sequence_length]):
inputs_fw = inputs
inputs_bw = tf.reverse_sequence(inputs, sequence_length,
batch_axis=0, seq_axis=1)
with tf.variable_scope("forward"):
output_fw, state_fw = _gru_encoder(cell_fw, inputs_fw,
sequence_length, None,
dtype=dtype)
with tf.variable_scope("backward"):
output_bw, state_bw = _gru_encoder(cell_bw, inputs_bw,
sequence_length, None,
dtype=dtype)
output_bw = tf.reverse_sequence(output_bw, sequence_length,
batch_axis=0, seq_axis=1)
results = {
"annotation": tf.concat([output_fw, output_bw], axis=2),
"outputs": {
"forward": output_fw,
"backward": output_bw
},
"final_states": {
"forward": state_fw,
"backward": state_bw
}
}
return results
Example #29
| Source File: rnn.py From gntp with MIT License | 5 votes |
|
def fused_rnn_backward(fused_rnn, inputs, sequence_length,
initial_state=None, dtype=None, scope=None, time_major=True):
if not time_major:
inputs = tf.transpose(inputs, [1, 0, 2])
rev_inputs = tf.reverse_sequence(inputs, sequence_length, 0, 1)
rev_outputs, last_state = fused_rnn(rev_inputs, sequence_length=sequence_length, initial_state=initial_state,
dtype=dtype, scope=scope)
outputs = tf.reverse_sequence(rev_outputs, sequence_length, 0, 1)
if not time_major:
outputs = tf.transpose(outputs, [1, 0, 2])
return outputs, last_state
Example #30
| Source File: util.py From gntp with MIT License | 5 votes |
|
def fused_rnn_backward(fused_rnn, inputs, sequence_length,
initial_state=None, dtype=None, scope=None, time_major=True):
if not time_major:
inputs = tf.transpose(inputs, [1, 0, 2])
# assumes that time dim is 0 and batch is 1
rev_inputs = tf.reverse_sequence(inputs, sequence_length, 0, 1)
rev_outputs, last_state = fused_rnn(rev_inputs, sequence_length=sequence_length, initial_state=initial_state,
dtype=dtype, scope=scope)
outputs = tf.reverse_sequence(rev_outputs, sequence_length, 0, 1)
if not time_major:
outputs = tf.transpose(outputs, [1, 0, 2])
return outputs, last_state
