Merge pull request #68 from brandonwillard/update-tf-dep-versions

Update pinned TF and TFP to latest versions

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')