Moving creation of data_id-related placeholders to feedable class

Plus, adding a pseudo-dummy register_input function which constructs the
placeholders.

Author: jindrahelcl

neuralmonkey/decoders/autoregressive.py

@@ -5,7 +5,7 @@
 The autoregressive decoder uses the while loop to get the outputs.
 Descendants should only specify the initial state and the while loop body.
 """
-from typing import NamedTuple, Callable, Tuple, Optional, Any, List
+from typing import NamedTuple, Callable, Tuple, Optional, Any, List, Dict
 
 import numpy as np
 import tensorflow as tf
@@ -19,7 +19,9 @@
 from neuralmonkey.model.sequence import EmbeddedSequence
 from neuralmonkey.nn.utils import dropout
 from neuralmonkey.tf_utils import get_variable, get_state_shape_invariants
-from neuralmonkey.vocabulary import Vocabulary, START_TOKEN, UNK_TOKEN_INDEX
+from neuralmonkey.vocabulary import (
+    Vocabulary, START_TOKEN, UNK_TOKEN_INDEX, START_TOKEN_INDEX,
+    PAD_TOKEN_INDEX)
 
 
 class LoopState(NamedTuple(
@@ -177,19 +179,25 @@ def embedding_size(self) -> int:
 
         return self.embeddings_source.embedding_matrix.get_shape()[1].value
 
-    # pylint: disable=no-self-use
     @tensor
     def go_symbols(self) -> tf.Tensor:
-        return tf.placeholder(tf.int32, [None], "go_symbols")
+        return tf.fill([self.batch_size], START_TOKEN_INDEX)
+
+    @property
+    def input_types(self) -> Dict[str, tf.DType]:
+        return {self.data_id: tf.int32}
+
+    @property
+    def input_shapes(self) -> Dict[str, tf.TensorShape]:
+        return {self.data_id: tf.TensorShape([None, None])}
 
     @tensor
     def train_inputs(self) -> tf.Tensor:
-        return tf.placeholder(tf.int32, [None, None], "train_inputs")
+        return self.dataset[self.data_id]
 
     @tensor
     def train_mask(self) -> tf.Tensor:
-        return tf.placeholder(tf.float32, [None, None], "train_mask")
-    # pylint: enable=no-self-use
+        return tf.to_float(tf.not_equal(self.train_inputs, PAD_TOKEN_INDEX))
 
     @tensor
     def decoding_w(self) -> tf.Variable:
@@ -479,12 +487,11 @@ def feed_dict(self, dataset: Dataset, train: bool = False) -> FeedDict:
         if sentences is not None:
             sentences_list = list(sentences)
             # train_mode=False, since we don't want to <unk>ize target words!
-            inputs, weights = self.vocabulary.sentences_to_tensor(
+            inputs, _ = self.vocabulary.sentences_to_tensor(
                 sentences_list, self.max_output_len, train_mode=False,
                 add_start_symbol=False, add_end_symbol=True,
                 pad_to_max_len=False)
 
             fd[self.train_inputs] = inputs
-            fd[self.train_mask] = weights
 
         return fd

neuralmonkey/decoders/beam_search_decoder.py

@@ -21,7 +21,10 @@
 """
 # pylint: disable=too-many-lines
 # Maybe move the definitions of the named tuple structures to a separate file?
-from typing import NamedTuple, List, Callable, Any
+from typing import Any, Callable, List, NamedTuple
+# pylint: disable=unused-import
+from typing import Optional
+# pylint: enable=unused-import
 
 import tensorflow as tf
 from typeguard import check_argument_types
@@ -159,11 +162,14 @@ def __init__(self,
         # max_steps attribute set to one.
         self.max_steps = tf.placeholder_with_default(self.max_steps_int, [])
 
+        self._initial_loop_state = None  # type: Optional[BeamSearchLoopState]
+
+    @tensor
+    def outputs(self) -> tf.Tensor:
         # This is an ugly hack for handling the whole graph when expanding to
         # the beam. We need to access all the inner states of the network in
         # the graph, replace them with beam-size-times copied originals, create
         # the beam search graph, and then replace the inner states back.
-        self._building = False
 
         enc_states = self.parent_decoder.encoder_states
         enc_masks = self.parent_decoder.encoder_masks
@@ -175,13 +181,21 @@ def __init__(self,
 
         # Create the beam search symbolic graph.
         with self.use_scope():
-            self.initial_loop_state = self.get_initial_loop_state()
-            self.outputs = self.decoding_loop()
+            self._initial_loop_state = self.get_initial_loop_state()
+            outputs = self.decoding_loop()
 
         # Reassign the original encoder states and mask back
         setattr(self.parent_decoder, "encoder_states", enc_states)
         setattr(self.parent_decoder, "encoder_masks", enc_masks)
 
+        return outputs
+
+    @property
+    def initial_loop_state(self) -> BeamSearchLoopState:
+        if self._initial_loop_state is None:
+            raise RuntimeError("Initial loop state was not initialized")
+        return self._initial_loop_state
+
     @property
     def vocabulary(self) -> Vocabulary:
         return self.parent_decoder.vocabulary

neuralmonkey/decoders/classifier.py

@@ -1,4 +1,4 @@
-from typing import Callable, List
+from typing import Callable, Dict, List
 
 import tensorflow as tf
 from typeguard import check_argument_types
@@ -62,11 +62,17 @@ def __init__(self,
         self.max_output_len = 1
     # pylint: enable=too-many-arguments
 
-    # pylint: disable=no-self-use
+    @property
+    def input_types(self) -> Dict[str, tf.DType]:
+        return {self.data_id: tf.int32}
+
+    @property
+    def input_shapes(self) -> Dict[str, tf.TensorShape]:
+        return {self.data_id: tf.TensorShape([None])}
+
     @tensor
     def gt_inputs(self) -> tf.Tensor:
-        return tf.placeholder(tf.int32, [None], "targets")
-    # pylint: enable=no-self-use
+        return self.dataset[self.data_id]
 
     @tensor
     def _mlp(self) -> MultilayerPerceptron:

neuralmonkey/decoders/sequence_labeler.py

@@ -1,4 +1,4 @@
-from typing import Union
+from typing import Dict, Union
 
 import tensorflow as tf
 from typeguard import check_argument_types
@@ -11,7 +11,7 @@
 from neuralmonkey.model.parameterized import InitializerSpecs
 from neuralmonkey.model.model_part import ModelPart
 from neuralmonkey.tf_utils import get_variable
-from neuralmonkey.vocabulary import Vocabulary
+from neuralmonkey.vocabulary import Vocabulary, PAD_TOKEN_INDEX
 
 
 class SequenceLabeler(ModelPart):
@@ -38,15 +38,21 @@ def __init__(self,
         self.dropout_keep_prob = dropout_keep_prob
     # pylint: enable=too-many-arguments
 
-    # pylint: disable=no-self-use
+    @property
+    def input_types(self) -> Dict[str, tf.DType]:
+        return {self.data_id: tf.int32}
+
+    @property
+    def input_shapes(self) -> Dict[str, tf.TensorShape]:
+        return {self.data_id: tf.TensorShape([None, None])}
+
     @tensor
     def train_targets(self) -> tf.Tensor:
-        return tf.placeholder(tf.int32, [None, None], "targets")
+        return self.dataset[self.data_id]
 
     @tensor
-    def train_weights(self) -> tf.Tensor:
-        return tf.placeholder(tf.float32, [None, None], "padding")
-    # pylint: enable=no-self-use
+    def train_mask(self) -> tf.Tensor:
+        return tf.to_float(tf.not_equal(self.train_targets, PAD_TOKEN_INDEX))
 
     @property
     def rnn_size(self) -> int:
@@ -116,7 +122,7 @@ def cost(self) -> tf.Tensor:
 
         # loss is now of shape [batch, time]. Need to mask it now by
         # element-wise multiplication with weights placeholder
-        weighted_loss = loss * self.train_weights
+        weighted_loss = loss * self.train_mask
         return tf.reduce_sum(weighted_loss)
 
     @property
@@ -132,10 +138,8 @@ def feed_dict(self, dataset: Dataset, train: bool = False) -> FeedDict:
 
         sentences = dataset.maybe_get_series(self.data_id)
         if sentences is not None:
-            vectors, paddings = self.vocabulary.sentences_to_tensor(
+            vectors, _ = self.vocabulary.sentences_to_tensor(
                 list(sentences), pad_to_max_len=False, train_mode=train)
 
             fd[self.train_targets] = vectors.T
-            fd[self.train_weights] = paddings.T
-
         return fd

neuralmonkey/decoders/sequence_regressor.py

@@ -1,4 +1,4 @@
-from typing import Callable, List
+from typing import Callable, Dict, List
 
 import tensorflow as tf
 from typeguard import check_argument_types
@@ -46,11 +46,17 @@ def __init__(self,
         self._dropout_keep_prob = dropout_keep_prob
     # pylint: enable=too-many-arguments
 
-    # pylint: disable=no-self-use
+    @property
+    def input_types(self) -> Dict[str, tf.DType]:
+        return {self.data_id: tf.float32}
+
+    @property
+    def input_shapes(self) -> Dict[str, tf.TensorShape]:
+        return {self.data_id: tf.TensorShape([None])}
+
     @tensor
     def train_inputs(self) -> tf.Tensor:
-        return tf.placeholder(tf.float32, [None], "targets")
-    # pylint: enable=no-self-use
+        return self.dataset[self.data_id]
 
     @tensor
     def _mlp_input(self):

neuralmonkey/decoders/word_alignment_decoder.py

@@ -1,4 +1,5 @@
-from typing import cast, Tuple
+# TODO untested module
+from typing import cast, Dict, Tuple
 
 import numpy as np
 import tensorflow as tf
@@ -42,14 +43,18 @@ def enc_input(self) -> Sequence:
 
         return cast(Sequence, self.encoder.input_sequence)
 
+    @property
+    def input_types(self) -> Dict[str, tf.DType]:
+        return {self.data_id: tf.float32}
+
+    @property
+    def input_shapes(self) -> Dict[str, tf.TensorShape]:
+        return {self.data_id: tf.TensorShape(
+            [None, self.decoder.max_output_len, self.enc_input.max_length])}
+
     @tensor
     def ref_alignment(self) -> tf.Tensor:
-        # TODO dynamic shape?
-        return tf.placeholder(
-            dtype=tf.float32,
-            shape=[None, self.decoder.max_output_len,
-                   self.enc_input.max_length],
-            name="ref_alignment")
+        return self.dataset[self.data_id]
 
     @tensor
     def alignment_target(self) -> tf.Tensor:

neuralmonkey/encoders/cnn_encoder.py

@@ -1,6 +1,6 @@
 """CNN for image processing."""
 
-from typing import cast, Callable, List, Tuple, Union
+from typing import cast, Callable, Dict, List, Tuple, Union
 from typeguard import check_argument_types
 
 import numpy as np
@@ -83,20 +83,24 @@ def __init__(self,
         self.batch_normalize = batch_normalize
     # pylint: enable=too-many-arguments, too-many-locals
 
+    @property
+    def input_types(self) -> Dict[str, tf.DType]:
+        return {self.data_id: tf.float32}
+
+    @property
+    def input_shapes(self) -> Dict[str, tf.TensorShape]:
+        return {self.data_id: tf.TensorShape(
+            [None, self.image_height, self.image_width, self.pixel_dim])}
+
     @tensor
     def image_input(self) -> tf.Tensor:
-        return tf.placeholder(
-            tf.float32,
-            shape=(None, self.image_height, self.image_width,
-                   self.pixel_dim),
-            name="input_images")
+        return self.dataset[self.data_id]
 
     @tensor
     def image_mask(self) -> tf.Tensor:
-        return tf.placeholder(
-            tf.float32,
-            shape=(None, self.image_height, self.image_width, 1),
-            name="input_mask")
+        # the image mask is one everywhere where the image is non-zero, i.e.
+        # zero pixels are masked out
+        return tf.sign(tf.reduce_sum(self.image_input, axis=3, keepdims=True))
 
     def batch_norm_callback(self, layer_output: tf.Tensor) -> tf.Tensor:
         if self.batch_normalize:
@@ -198,13 +202,7 @@ def feed_dict(self, dataset: Dataset, train: bool = False) -> FeedDict:
         # if it is from the pickled file, it is a list, not a numpy tensor,
         # so convert it as as a prevention
         images = np.array(list(dataset.get_series(self.data_id)))
-
         fd[self.image_input] = images / 255.0
-
-        # the image mask is one everywhere where the image is non-zero, i.e.
-        # zero pixels are masked out
-        fd[self.image_mask] = np.sign(np.sum(images, axis=3, keepdims=True))
-
         return fd
 
 

neuralmonkey/encoders/imagenet_encoder.py

@@ -1,9 +1,8 @@
 """Pre-trained ImageNet networks."""
 
-from typing import Callable, NamedTuple, Tuple, Optional, Any
 import sys
+from typing import Any, Callable, Dict, NamedTuple, Optional, Tuple
 
-from typeguard import check_argument_types
 import numpy as np
 import tensorflow as tf
 import tensorflow.contrib.slim as tf_slim
@@ -12,6 +11,7 @@
 # see https://github.com/tensorflow/tensorflow/issues/6064
 import tensorflow.contrib.slim.nets
 # pylint: enable=unused-import
+from typeguard import check_argument_types
 
 from neuralmonkey.dataset import Dataset
 from neuralmonkey.decorators import tensor
@@ -158,6 +158,19 @@ def __init__(self,
         self.net_specification = SUPPORTED_NETWORKS[self.network_type]()
         self.height, self.width = self.net_specification.image_size
 
+    @property
+    def input_types(self) -> Dict[str, tf.DType]:
+        return {self.data_id: tf.float32}
+
+    @property
+    def input_shapes(self) -> Dict[str, tf.TensorShape]:
+        return {
+            self.data_id: tf.TensorShape([None, self.height, self.width, 3])}
+
+    @tensor
+    def input_image(self) -> tf.Tensor:
+        return self.dataset[self.data_id]
+
     @tensor
     def end_points(self) -> Any:
         with tf_slim.arg_scope(self.net_specification.scope()):
@@ -187,11 +200,6 @@ def end_points(self) -> Any:
 
         return end_points
 
-    @tensor
-    def input_image(self) -> tf.Tensor:
-        return tf.placeholder(
-            tf.float32, [None, self.height, self.width, 3])
-
     @tensor
     def spatial_states(self) -> Optional[tf.Tensor]:
         if self.spatial_layer is None: