Python tensorflow.contrib.seq2seq.GreedyEmbeddingHelper() Examples
The following are 5
code examples of tensorflow.contrib.seq2seq.GreedyEmbeddingHelper().
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.contrib.seq2seq
, or try the search function
.
.
Example #1
| Source File: seq2seq_helper.py From demo2program with MIT License | 5 votes |
|
def next_inputs(self, time, outputs, state, stop_id, name=None):
"""next_inputs_fn for GreedyEmbeddingHelper."""
del time # unused by next_inputs_fn
finished = math_ops.equal(stop_id, 1) # 1 is stop signal
all_finished = math_ops.reduce_all(finished)
next_inputs = control_flow_ops.cond(
all_finished,
# If we're finished, the next_inputs value doesn't matter
lambda: self._start_inputs,
lambda: outputs)
return (finished, next_inputs, state)
Example #2
| Source File: seq2seq_helper.py From demo2program with MIT License | 5 votes |
|
def next_inputs(self, time, outputs, state, sample_ids, name=None):
"""next_inputs_fn for GreedyEmbeddingHelper."""
del time, outputs # unused by next_inputs_fn
finished = math_ops.equal(sample_ids, self._end_token)
all_finished = math_ops.reduce_all(finished)
next_inputs = control_flow_ops.cond(
all_finished,
# If we're finished, the next_inputs value doesn't matter
lambda: self._start_inputs,
lambda: self._embedding_fn(sample_ids))
return (finished, next_inputs, state)
Example #3
| Source File: decoder_unimodal.py From avsr-tf1 with GNU General Public License v3.0 | 4 votes |
|
def _build_decoder_test_greedy(self):
r"""
Builds the greedy test decoder, which feeds the most likely decoded symbol as input for the
next timestep
"""
self._helper_greedy = seq2seq.GreedyEmbeddingHelper(
embedding=self._embedding_matrix,
start_tokens=tf.tile([self._GO_ID], [self._batch_size]),
end_token=self._EOS_ID)
if self._hparams.enable_attention is True:
cells, initial_state = add_attention(
cells=self._decoder_cells,
attention_types=self._hparams.attention_type[1],
num_units=self._hparams.decoder_units_per_layer[-1],
memory=self._encoder_memory,
memory_len=self._encoder_features_len,
beam_search=False,
batch_size=self._batch_size,
initial_state=self._decoder_initial_state,
mode=self._mode,
dtype=self._hparams.dtype,
fusion_type='linear_fusion',
write_attention_alignment=self._hparams.write_attention_alignment)
else:
cells = self._decoder_cells
initial_state = self._decoder_initial_state
self._decoder_inference = seq2seq.BasicDecoder(
cell=cells,
helper=self._helper_greedy,
initial_state=initial_state,
output_layer=self._dense_layer)
outputs, states, lengths = seq2seq.dynamic_decode(
self._decoder_inference,
impute_finished=True,
swap_memory=False,
maximum_iterations=self._hparams.max_label_length)
self.inference_outputs = outputs.rnn_output
self.inference_predicted_ids = outputs.sample_id
if self._hparams.write_attention_alignment is True:
self.attention_summary = self._create_attention_alignments_summary(states)
Example #4
| Source File: decoder_bimodal.py From avsr-tf1 with GNU General Public License v3.0 | 4 votes |
|
def _build_decoder_greedy(self):
batch_size, _ = tf.unstack(tf.shape(self._labels))
self._helper_greedy = seq2seq.GreedyEmbeddingHelper(
embedding=self._embedding_matrix,
start_tokens=tf.tile([self._GO_ID], [batch_size]),
end_token=self._EOS_ID)
if self._hparams.enable_attention is True:
attention_mechanisms, layer_sizes = self._create_attention_mechanisms()
attention_cells = seq2seq.AttentionWrapper(
cell=self._decoder_cells,
attention_mechanism=attention_mechanisms,
attention_layer_size=layer_sizes,
initial_cell_state=self._decoder_initial_state,
alignment_history=self._hparams.write_attention_alignment,
output_attention=self._output_attention
)
attn_zero = attention_cells.zero_state(
dtype=self._hparams.dtype, batch_size=batch_size
)
initial_state = attn_zero.clone(
cell_state=self._decoder_initial_state
)
cells = attention_cells
else:
cells = self._decoder_cells
initial_state = self._decoder_initial_state
self._decoder_inference = seq2seq.BasicDecoder(
cell=cells,
helper=self._helper_greedy,
initial_state=initial_state,
output_layer=self._dense_layer)
outputs, states, lengths = seq2seq.dynamic_decode(
self._decoder_inference,
impute_finished=True,
swap_memory=False,
maximum_iterations=self._hparams.max_label_length)
# self._result = outputs, states, lengths
self.inference_outputs = outputs.rnn_output
self.inference_predicted_ids = outputs.sample_id
if self._hparams.write_attention_alignment is True:
self.attention_summary = self._create_attention_alignments_summary(states)
Example #5
| Source File: seq2seq_model.py From AmusingPythonCodes with MIT License | 4 votes |
|
def _build_model(self):
with tf.variable_scope("embeddings"):
self.source_embs = tf.get_variable(name="source_embs", shape=[self.cfg.source_vocab_size, self.cfg.emb_dim],
dtype=tf.float32, trainable=True)
self.target_embs = tf.get_variable(name="embeddings", shape=[self.cfg.vocab_size, self.cfg.emb_dim],
dtype=tf.float32, trainable=True)
source_emb = tf.nn.embedding_lookup(self.source_embs, self.enc_source)
target_emb = tf.nn.embedding_lookup(self.target_embs, self.dec_target_in)
print("source embedding shape: {}".format(source_emb.get_shape().as_list()))
print("target input embedding shape: {}".format(target_emb.get_shape().as_list()))
with tf.variable_scope("encoder"):
if self.cfg.use_bi_rnn:
with tf.variable_scope("bi-directional_rnn"):
cell_fw = GRUCell(self.cfg.num_units) if self.cfg.cell_type == "gru" else \
LSTMCell(self.cfg.num_units)
cell_bw = GRUCell(self.cfg.num_units) if self.cfg.cell_type == "gru" else \
LSTMCell(self.cfg.num_units)
bi_outputs, _ = bidirectional_dynamic_rnn(cell_fw, cell_bw, source_emb, dtype=tf.float32,
sequence_length=self.enc_seq_len)
source_emb = tf.concat(bi_outputs, axis=-1)
print("bi-directional rnn output shape: {}".format(source_emb.get_shape().as_list()))
input_project = tf.layers.Dense(units=self.cfg.num_units, dtype=tf.float32, name="input_projection")
source_emb = input_project(source_emb)
print("encoder input projection shape: {}".format(source_emb.get_shape().as_list()))
enc_cells = self._create_encoder_cell()
self.enc_outputs, self.enc_states = dynamic_rnn(enc_cells, source_emb, sequence_length=self.enc_seq_len,
dtype=tf.float32)
print("encoder output shape: {}".format(self.enc_outputs.get_shape().as_list()))
with tf.variable_scope("decoder"):
self.max_dec_seq_len = tf.reduce_max(self.dec_seq_len, name="max_dec_seq_len")
self.dec_cells, self.dec_init_states = self._create_decoder_cell()
# define input and output projection layer
input_project = tf.layers.Dense(units=self.cfg.num_units, name="input_projection")
self.dense_layer = tf.layers.Dense(units=self.cfg.vocab_size, name="output_projection")
if self.mode == "train": # either "train" or "decode"
# for training
target_emb = input_project(target_emb)
train_helper = TrainingHelper(target_emb, sequence_length=self.dec_seq_len, name="train_helper")
train_decoder = BasicDecoder(self.dec_cells, helper=train_helper, output_layer=self.dense_layer,
initial_state=self.dec_init_states)
self.dec_output, _, _ = dynamic_decode(train_decoder, impute_finished=True,
maximum_iterations=self.max_dec_seq_len)
print("decoder output shape: {} (vocab size)".format(self.dec_output.rnn_output.get_shape().as_list()))
# for decode
start_token = tf.ones(shape=[self.batch_size, ], dtype=tf.int32) * self.cfg.target_dict[GO]
end_token = self.cfg.target_dict[EOS]
def inputs_project(inputs):
return input_project(tf.nn.embedding_lookup(self.target_embs, inputs))
dec_helper = GreedyEmbeddingHelper(embedding=inputs_project, start_tokens=start_token,
end_token=end_token)
infer_decoder = BasicDecoder(self.dec_cells, helper=dec_helper, initial_state=self.dec_init_states,
output_layer=self.dense_layer)
infer_dec_output, _, _ = dynamic_decode(infer_decoder, maximum_iterations=self.cfg.maximum_iterations)
self.dec_predicts = infer_dec_output.sample_id
