Update to TensorFlow 1.1, and misc bugfixes.

Author: delesley

WORKSPACE

@@ -7,6 +7,18 @@ local_repository(
  path = "tensorflow",
 )
 
+# TensorFlow depends on "io_bazel_rules_closure" so we need this here.
+# Needs to be kept in sync with the same target in TensorFlow's WORKSPACE file.
+http_archive(
+ name = "io_bazel_rules_closure",
+ sha256 = "60fc6977908f999b23ca65698c2bb70213403824a84f7904310b6000d78be9ce",
+ strip_prefix = "rules_closure-5ca1dab6df9ad02050f7ba4e816407f88690cf7d",
+ urls = [
+ "http://bazel-mirror.storage.googleapis.com/github.com/bazelbuild/rules_closure/archive/5ca1dab6df9ad02050f7ba4e816407f88690cf7d.tar.gz", # 2017-02-03
+ "https://github.com/bazelbuild/rules_closure/archive/5ca1dab6df9ad02050f7ba4e816407f88690cf7d.tar.gz",
+ ],
+)
+
 # Import all of the tensorflow dependencies.
 load('//tensorflow_fold:workspace.bzl', 'tf_fold_workspace')
 tf_fold_workspace()

tensorflow

@@ -140,6 +140,7 @@ fold_py_library(
  ":util",
  # numpy",
  "@org_tensorflow//tensorflow:tensorflow_py",
+ "@org_tensorflow//tensorflow/python/debug:debug_py",
  ],
 )
 

tensorflow_fold/blocks/BUILD

@@ -408,7 +408,7 @@ def init_loom(self, max_depth=None, loom_input_tensor=None, input_tensor=None,
  'loom_input_tensor for the same compiler')
  self._input_tensor = input_tensor
  loom_input_tensor = tf.py_func(
- self.build_loom_input_batched,
+ lambda inp: np.asarray(self.build_loom_input_batched(inp), np.object),
  [self._input_tensor], [tf.string], name='Scheduler')
  passthrough_types = (self._dry.tagging_op.passthrough_types
  if self._dry.tagging_op else None)

tensorflow_fold/blocks/block_compiler.py

@@ -82,6 +82,7 @@ def __init__(self, children=None, input_type=None, output_type=None,
  self._children = []
  self._constructor_name = None
  self._constructor_args = None
+ self._constructor_kwargs = None
  if children is not None:
  for b in children:
  self._add_child(b)
@@ -90,7 +91,7 @@ def __init__(self, children=None, input_type=None, output_type=None,
  self._propagate_types_from_child(child)
 
  def __repr__(self):
- strs = ['td.%s' % (self._constructor_name or type(self).__name__,)]
+ strs = [self._constructor_name or ('td.%s' % type(self).__name__)]
  if self._name: strs.append('%r' % self._name)
  for k, v in sorted(six.iteritems(self._repr_kwargs())):
  if isinstance(v, functools.partial): v = v.func
@@ -117,6 +118,24 @@ def set_constructor_args(self, *constructor_args):
  self._constructor_args = constructor_args
  return self
 
+ def set_constructor_name_args(self, name, args, kwargs):
+ """Sets the constructor args used to pretty-print this layer.
+
+ Should be called by derived classes in __init__.
+
+ Args:
+ name: the fully qualified name of the constructor
+ args: a list of constructor arguments
+ kwargs: a list of (key,value,default) triples for keyword arguments
+
+ Returns:
+ self
+ """
+ self._constructor_name = name
+ self._constructor_args = args
+ self._constructor_kwargs = kwargs if kwargs is not None else []
+ return self
+
  def _add_child(self, b):
  assert isinstance(b, Block) # internal consistency check
  if b.parent is not None:
@@ -282,9 +301,9 @@ def __init__(self, shape, dtype='float32', name=None):
 
  def _repr_kwargs(self):
  kwargs = {'dtype': self.output_type.dtype}
- if self._constructor_name == 'Vector':
+ if self._constructor_name == 'td.Vector':
  kwargs['size'] = self.output_type.shape[0]
- elif self._constructor_name != 'Scalar':
+ elif self._constructor_name != 'td.Scalar':
  kwargs['shape'] = self.output_type.shape
  return kwargs
 
@@ -299,13 +318,13 @@ def _evaluate(self, eval_ctx, x):
 def Scalar(dtype='float32', name=None): # pylint: disable=invalid-name
  """A block that converts its input to a scalar."""
  return Tensor(shape=[], dtype=dtype, name=name).set_constructor_name(
- 'Scalar')
+ 'td.Scalar')
 
 
 def Vector(size, dtype='float32', name=None): # pylint: disable=invalid-name
  """A block that converts its input to a vector."""
  return Tensor(shape=[size], dtype=dtype, name=name).set_constructor_name(
- 'Vector')
+ 'td.Vector')
 
 
 class FromTensor(Block):
@@ -493,7 +512,7 @@ def SerializedMessageToTree(message_type_name): # pylint: disable=invalid-name
  return InputTransform(functools.partial(
  proto_tools.serialized_message_to_tree, message_type_name),
  name=message_type_name).set_constructor_name(
- 'SerializedMessageToTree')
+ 'td.SerializedMessageToTree')
 
 
 class GetItem(Block):
@@ -581,7 +600,8 @@ def Slice(*args, **kwargs): # pylint: disable=invalid-name
  raise TypeError('Slice does not accept positional arguments; allowed '
  'keyword arguments are start, stop, and step')
  name = kwargs.pop('name', None)
- return GetItem(_get_slice(**kwargs), name=name).set_constructor_name('Slice')
+ return GetItem(_get_slice(**kwargs), name=name).set_constructor_name(
+ 'td.Slice')
 
 
 def _get_slice(start=None, stop=None, step=None):
@@ -630,7 +650,7 @@ def __init__(self, input_type, output_type, name):
  self._target_block = None
  super(_ForwardDeclarationRef, self).__init__(
  input_type=input_type, output_type=output_type, name=name)
- self.set_constructor_name('ForwardDeclaration()')
+ self.set_constructor_name('td.ForwardDeclaration()')
 
  def _update_input_type(self):
  if self._target_block is not None:
@@ -677,7 +697,7 @@ def __init__(self, parent, parent_name, is_input):
  placeholder_name = 'output'
  self._update_parent = parent.set_output_type
  super(_ComposeIO, self).__init__(name=parent_name)
- self.set_constructor_name('Composition.%s' % placeholder_name)
+ self.set_constructor_name('td.Composition.%s' % placeholder_name)
  self._parent = parent
 
  def _update_input_type(self):
@@ -989,29 +1009,29 @@ def Pipe(*blocks, **kwargs): # pylint: disable=invalid-name
  ```
 
  Args:
- *blocks: A tuple of blocks.
- **kwargs: `{'name': name_string}` or `{}`.
+ *blocks:  A tuple of blocks.
+ **kwargs:  Optional keyword arguments. Accepts name='block_name'.
 
  Returns:
  A block.
  """
- return _pipe([convert_to_block(b) for b in blocks],
- **kwargs).set_constructor_name('Pipe')
+ blocks = [convert_to_block(b) for b in blocks]
+ blocks = [b for b in blocks if not isinstance(b, Identity)]
+ if not blocks: return Identity(**kwargs)
+ if len(blocks) == 1: return blocks[0]
+ return _pipe(blocks, **kwargs)
 
 
 def _pipe(blocks, name=None):
  """Internal implementation of Pipe."""
- if not blocks: return Identity(name=name)
- if len(blocks) == 1: return blocks[0]
-
  c = Composition(blocks, name=name)
  c.connect(c.input, blocks[0])
  prev = blocks[0]
  for b in blocks[1:]:
  c.connect(prev, b)
  prev = b
  c.connect(prev, c.output)
- return c
+ return c.set_constructor_name('td.Pipe')
 
 
 class Record(Block):
@@ -1135,15 +1155,18 @@ def AllOf(*blocks, **kwargs): # pylint: disable=invalid-name
  Returns:
  See above.
  """
- return _all_of([convert_to_block(b) for b in blocks],
- **kwargs).set_constructor_name('AllOf')
+ blocks = [convert_to_block(b) for b in blocks]
+ c = _all_of(blocks, **kwargs)
+ c.set_constructor_name('td.AllOf')
+ c.set_constructor_args(*blocks)
+ return c
 
 
 def _all_of(blocks, name=None):
  """Internal implementation of AllOf."""
  if not blocks: return Void(name=name)
  if len(blocks) == 1:
- # TODO(moshelooks): fix composition to allow for tuple output.
+ # TODO(delesley): fix composition to allow for tuple output.
  return Pipe(blocks[0], AllOf(Identity(), Identity()), Slice(stop=1),
  name=name)
  c = Composition(blocks, name=name)
@@ -1291,7 +1314,6 @@ def __init__(self, rnn_cell_block, name=None):
  """
  self._rnn_cell_block = convert_to_block(rnn_cell_block)
  super(_RNN, self).__init__(children=[self._rnn_cell_block], name=name)
- self.set_constructor_name('RNN')
 
  def _repr_kwargs(self):
  return dict(rnn_cell_block=self.rnn_cell_block)
@@ -1402,12 +1424,15 @@ def RNN(cell, initial_state=None, # pylint: disable=invalid-name
  a block.
  """
  cell = convert_to_block(cell)
+ (args, kwargs) = _get_local_args(RNN)
 
  if initial_state_from_input:
  if initial_state is not None:
  raise ValueError('Cannot specify initial_state if '
  'initial_state_from_input is True.')
- return _RNN(cell, name=name)
+ rnn = _RNN(cell, name=name)
+ rnn.set_constructor_name_args('td.RNN', args, kwargs)
+ return rnn
 
  # Otherwise create a composition to wire in initial_state.
  if initial_state is None:
@@ -1421,10 +1446,11 @@ def RNN(cell, initial_state=None, # pylint: disable=invalid-name
  else:
  initial_state = convert_to_block(initial_state)
 
- c = Composition(name=name).set_constructor_name('RNN')
+ c = Composition(name=name).set_constructor_name('td.RNN')
  with c.scope():
  rnn = _RNN(cell, name=name).reads(c.input, initial_state)
  c.output.reads(rnn)
+ c.set_constructor_name_args('td.RNN', args, kwargs)
  return c
 
 
@@ -1484,17 +1510,17 @@ def _evaluate(self, eval_ctx, x):
 
 def Sum(name=None): # pylint: disable=invalid-name
  """Sums its inputs."""
- return Reduce(Function(tf.add), name=name).set_constructor_name('Sum')
+ return Reduce(Function(tf.add), name=name).set_constructor_name('td.Sum')
 
 
 def Min(name=None): # pylint: disable=invalid-name
  """Takes the minimum of its inputs. Zero on no inputs."""
- return Reduce(Function(tf.minimum), name=name).set_constructor_name('Min')
+ return Reduce(Function(tf.minimum), name=name).set_constructor_name('td.Min')
 
 
 def Max(name=None): # pylint: disable=invalid-name
  """Takes the maximum of its inputs. Zero on no inputs."""
- return Reduce(Function(tf.maximum), name=name).set_constructor_name('Max')
+ return Reduce(Function(tf.maximum), name=name).set_constructor_name('td.Max')
 
 
 def _tf_safe_reciprocal(x):
@@ -1517,7 +1543,7 @@ def Mean(name=None): # pylint: disable=invalid-name
  with c.scope():
  c.output.reads(Function(_tf_batch_safe_scalar_division).reads(
  Sum().reads(c.input), Length().reads(c.input)))
- return c.set_constructor_name('Mean')
+ return c.set_constructor_name('td.Mean')
 
 
 class OneOf(Block):
@@ -1929,7 +1955,7 @@ def OneHotFromList(elements, dtype='float32', strict=True, name=None): # pylint
  key_fn = lambda x: indices.get(x, -1)
 
  return OneOf(key_fn, tensors, pre_block=Void(),
- name=name).set_constructor_name('OneHotFromList')
+ name=name).set_constructor_name('td.OneHotFromList')
 
 
 class Nth(Block):
@@ -1999,13 +2025,13 @@ def Zeros(output_type, name=None): # pylint: disable=invalid-name
  result = _EmptySequence(input_type=tdt.VoidType(), output_type=output_type,
  name=name)
  result.set_constructor_args(pp_output_type)
- return result.set_constructor_name('Zeros')
+ return result.set_constructor_name('td.Zeros')
 
 
 def Void(name=None): # pylint: disable=invalid-name
  """A block with void output type that accepts any input type."""
  return Composition(name=name).set_output_type(
- tdt.VoidType()).set_constructor_name('Void')
+ tdt.VoidType()).set_constructor_name('td.Void').set_constructor_args()
 
 
 def convert_to_block(block_like):
@@ -2111,3 +2137,7 @@ def _evaluate(self, unused_eval_ctx, unused_x):
 def _is_layer(x):
  return isinstance(
  x, tensorflow_fold.blocks.layers.Layer)
+
+
+_get_local_args = (
+ tensorflow_fold.blocks.layers.get_local_arguments)

tensorflow_fold/blocks/blocks.py

@@ -71,7 +71,13 @@ def assertBuilds(self, desired, block, inp, max_depth=1, feed_dict=None):
  self.assertSameStructure(desired_out, out[0].tolist())
 
  def assertBuildsConst(self, desired, block, inp):
- # TODO(moshelooks): actually test constness
+ # In this context 'const' means a block that can be evaluated
+ # entirely in python, without running TF at all. For example,
+ # (td.Map(td.Scalar()) >> td.Sum()) is const.
+ #
+ # There currently are no optimizations in Fold for const
+ # blocks. If/when these are implemented, code should go here for
+ # testing that 'block' is in fact const.
  self.assertBuilds(desired, block, inp, max_depth=None)
 
  def test_scalar(self):
@@ -301,13 +307,14 @@ def test_composition_slice(self):
  self.assertBuilds(4, c1, None, max_depth=1)
 
  def test_composition_backward_type_inference(self):
- b = tdb.Map(tdb.Identity()) >> tdb.Identity() >> tdb.Identity()
+ b = tdb._pipe([tdb.Map(tdb.Identity()), tdb.Identity(), tdb.Identity()])
  six.assertRaisesRegex(
  self, TypeError, 'bad output type VoidType',
  b.output.set_output_type, tdt.VoidType())
 
  def test_composition_forward_type_inference(self):
- b = tdb.Identity() >> tdb.Identity() >> tdb.Map(tdb.Function(tf.negative))
+ b = tdb._pipe([tdb.Identity(), tdb.Identity(),
+ tdb.Map(tdb.Function(tf.negative))])
  six.assertRaisesRegex(
  self, TypeError, 'bad input type PyObjectType',
  b.input.set_input_type, tdt.PyObjectType())
@@ -1090,8 +1097,9 @@ def test_repr(self):
  tdb.Composition(name='x').output: '<td.Composition.output \'x\'>',
  tdb.Composition(name='x'): '<td.Composition \'x\'>',
 
- tdb.Pipe(): '<td.Pipe>',
- tdb.Pipe(tdb.Scalar(), tdb.Identity()): '<td.Pipe>',
+ tdb.Pipe(): '<td.Identity>',
+ tdb.Pipe(tdb.Scalar(), tdb.Identity()): '<td.Scalar dtype=\'float32\'>',
+ tdb.Pipe(tdb.InputTransform(ord), tdb.Scalar('int32')): '<td.Pipe>',
 
  tdb.Record({}, name='x'): '<td.Record \'x\' ordered=False>',
  tdb.Record((), name='x'): '<td.Record \'x\' ordered=True>',