Update pinned TF and TFP to latest versions

These updates required changes to the TF tensor and operation name handling,
since TF seems to have changed the OpDefs behind __add__ addition.  Likewise,
these name changes smooth out some pre-existing inconsistencies between method
and function-based operations in TF (e.g. __mul__ would use the lower-case
"mul", which goes against their capitalized naming convention used in most other
cases).

Comparisons using TFlowOpName are now case insensitive (for better or worse).
Also, the Operation name is now used as the name value returned by
TFlowMetaTensor.inputs, along with other related fixes that allow
TFlowMetaTensor.op to be a logic variable.

Author: brandonwillard

.pylintrc

@@ -264,7 +264,7 @@ ignore-mixin-members=yes
 # (useful for modules/projects where namespaces are manipulated during runtime
 # and thus existing member attributes cannot be deduced by static analysis. It
 # supports qualified module names, as well as Unix pattern matching.
-ignored-modules=
+ignored-modules=tensorflow.core.framework,tensorflow.python.framework
 
 # List of classes names for which member attributes should not be checked
 # (useful for classes with attributes dynamically set). This supports can work

requirements.txt

@@ -1,7 +1,9 @@
 scipy>=1.2.0
 Theano>=1.0.4
-tf-nightly-2.0-preview==2.0.0.dev20190606
-tfp-nightly==0.8.0.dev20190705
+gast==0.2.2
+tf-nightly-2.0-preview==2.0.0.dev20190908
+tensorflow-estimator-2.0-preview==1.14.0.dev2019090801
+tfp-nightly==0.9.0.dev20190908
 pymc3>=3.6
 pymc4 @ git+https://github.com/pymc-devs/pymc4.git@master#egg=pymc4-0.0.1
 multipledispatch>=0.6.0

symbolic_pymc/tensorflow/meta.py

@@ -170,7 +170,10 @@ def __eq__(self, other):
         if type(self) != type(other):
             return False
 
-        return self._unique_name == other._unique_name and self._in_idx == other._in_idx
+        return (
+            self._unique_name.lower() == other._unique_name.lower()
+            and self._in_idx == other._in_idx
+        )
 
     def __hash__(self):
         return hash((self._unique_name, self._in_idx))
@@ -309,7 +312,7 @@ def __call__(self, *args, **kwargs):
         # Get the `OpDef`-instantiating parameters and call them a "node_def".
         node_attr = {a.name: apply_arguments.get(a.name, a) for a in self.obj.attr}
 
-        op_name = op_kwargs.get("name", self.obj.name.lower())
+        op_name = op_kwargs.get("name", self.obj.name)
 
         # input_arg_names = [(getattr(a, 'name', None), i.name)
         #                    for a, i in zip(args, self.obj.input_arg)]
@@ -453,7 +456,7 @@ def __init__(self, op_def, node_def, inputs, name=None, outputs=None, obj=None):
 
             if isinstance(name, (str, TFlowOpName)) or name is None:
                 if name is None:
-                    name = op_def.obj.name.lower()
+                    name = op_def.obj.name
                 # from tensorflow.python.framework import ops
                 # if name and name[-1] == "/":
                 #     name = ops._name_from_scope_name(str(name))
@@ -512,7 +515,7 @@ def outputs(self):
                 value_index=i,
                 shape=var(),
                 name=(
-                    TFlowOpName(f"{self.name.lower()}:{i}")
+                    TFlowOpName(f"{self.name}:{i}")
                     if isinstance(self.name, (str, TFlowOpName))
                     else var()
                 ),
@@ -536,8 +539,6 @@ def default_output(self):
 
         mt_outs = self.outputs
 
-        if isvar(mt_outs):
-            out_var = var()
         if len(mt_outs) == 1:
             out_var = mt_outs[0]
         else:
@@ -553,8 +554,13 @@ def reify(self):
         # tt_op = self.op.reify()
         # if not self.is_meta(tt_op):
         op_inputs, op_inputs_unreified = _meta_reify_iter(self.inputs)
+
+        if isvar(self.node_def):
+            return self
+
         op_attrs, op_attrs_unreified = _meta_reify_iter(self.node_def.attr)
-        if not op_inputs_unreified and not op_attrs_unreified and not MetaSymbol.is_meta(self.name):
+
+        if not (op_inputs_unreified or op_attrs_unreified or MetaSymbol.is_meta(self.name)):
 
             # We have to use a primitive string or TF will complain.
             name = self.name
@@ -644,22 +650,24 @@ def operator(self):
     def inputs(self):
         """Return the tensor's inputs/rands.
 
-        NOTE: These inputs differ from `self.op.inputs` in that contain
+        NOTE: These inputs differ from `self.op.inputs` in that they contain
         the `node_def` parameters, as well.
         In other words, these can be used to recreate this object (per
         the meta object spec).
         """
         if self.op is not None and not isvar(self.op):
             input_args = self.op.op_def.input_args(
-                *self.op.inputs, name=self.op.name, **self.op.node_def.attr
+                *self.op.inputs,
+                name=self.op.name if not isvar(self.op.name) else None,
+                **self.op.node_def.attr,
             )
             return tuple(input_args.values())
 
     def reify(self):
         if self.obj is not None and not isinstance(self.obj, Var):
             return self.obj
 
-        if not self.op:
+        if (not self.op) or isvar(self.op):
             op_res = super().reify()
             return op_res
 
@@ -793,7 +801,7 @@ def __call__(self, x):
     @classmethod
     def find_opdef(cls, name):
         """Attempt to create a meta `OpDef` for a given TF function/`Operation` name."""
-        raw_op_name = op_def_lib.lower_op_name_to_raw.get(name, name)
+        raw_op_name = op_def_lib.lower_op_name_to_raw.get(name.lower(), name)
         op_def = op_def_registry.get_registered_ops()[raw_op_name]
 
         if op_def is not None:

tests/tensorflow/test_meta.py

@@ -8,6 +8,7 @@
 
 from unification import var, isvar
 
+from symbolic_pymc.meta import MetaSymbol
 from symbolic_pymc.tensorflow.meta import (TFlowMetaTensor,
                                            TFlowMetaTensorShape,
                                            TFlowMetaConstant,
@@ -166,6 +167,35 @@ def test_meta_create():
     with pytest.raises(TypeError):
         TFlowMetaTensor('float64', 'Add', name='q__')
 
+@pytest.mark.usefixtures("run_with_tensorflow")
+@run_in_graph_mode
+def test_meta_Op():
+
+    from tensorflow.python.eager.context import graph_mode
+
+
+    with graph_mode():
+        t1_tf = tf.convert_to_tensor([[1, 2, 3], [4, 5, 6]])
+        t2_tf = tf.convert_to_tensor([[7, 8, 9], [10, 11, 12]])
+        test_out_tf = tf.concat([t1_tf, t2_tf], 0)
+
+        # TODO: Without explicit conversion, each element within these arrays gets
+        # converted to a `Tensor` by `metatize`.  That doesn't seem very
+        # reasonable.  Likewise, the `0` gets converted, but it probably shouldn't be.
+        test_op = TFlowMetaOp(mt.Concat, var(), [[t1_tf, t2_tf], 0])
+
+        # Make sure we converted lists to tuples
+        assert isinstance(test_op.inputs, tuple)
+        assert isinstance(test_op.inputs[0], tuple)
+
+        test_op = TFlowMetaOp(mt.Concat, var(), [[t1_tf, t2_tf], 0], outputs=[test_out_tf])
+
+        # NodeDef is a logic variable, so this shouldn't actually reify.
+        assert MetaSymbol.is_meta(test_op.reify())
+        assert isinstance(test_op.outputs, tuple)
+        assert MetaSymbol.is_meta(test_op.outputs[0])
+
+
 
 @pytest.mark.usefixtures("run_with_tensorflow")
 def test_meta_lvars():

tests/tensorflow/test_unify.py

@@ -70,8 +70,8 @@ def test_basic_unify_reify():
     test_base_res = test_reify_res.reify()
     assert isinstance(test_base_res, tf.Tensor)
 
-    expected_res = (tf.constant(1, dtype=tf.float64) +
-                    tf.constant(2, dtype=tf.float64) * a)
+    expected_res = tf.add(tf.constant(1, dtype=tf.float64),
+                          tf.constant(2, dtype=tf.float64) * a)
     assert_ops_equal(test_base_res, expected_res)
 
     # Simply make sure that unification succeeds
@@ -94,7 +94,7 @@ def test_sexp_unify_reify():
     y = tf.compat.v1.placeholder(tf.float64, name='y',
                                  shape=tf.TensorShape([None, 1]))
 
-    z = tf.matmul(A, x + y)
+    z = tf.matmul(A, tf.add(x, y))
 
     z_sexp = etuplize(z)
 

tests/tensorflow/utils.py

@@ -2,6 +2,7 @@
 
 import tensorflow as tf
 
+
 def assert_ops_equal(a, b, compare_fn=lambda a, b: a.op.type == b.op.type):
     if hasattr(a, 'op') or hasattr(b, 'op'):
         assert hasattr(a, 'op') and hasattr(b, 'op')