Merge pull request #80 from brandonwillard/add-meta-object-creation-options

Add ability to disable base object generation and use logic variable defaults

Author: brandonwillard

.pylintrc

@@ -54,7 +54,6 @@ enable=import-error,
        unused-wildcard-import,
        global-variable-not-assigned,
        undefined-loop-variable,
-       global-statement,
        global-at-module-level,
        bad-open-mode,
        redundant-unittest-assert,
@@ -264,7 +263,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=tensorflow.core.framework,tensorflow.python.framework
+ignored-modules=tensorflow.core.framework,tensorflow.python.framework,tensorflow.python.ops.gen_linalg_ops
 
 # List of classes names for which member attributes should not be checked
 # (useful for classes with attributes dynamically set). This supports can work

symbolic_pymc/meta.py

@@ -5,6 +5,7 @@
 from itertools import chain
 from functools import partial
 from collections import OrderedDict
+from contextlib import contextmanager
 from collections.abc import Iterator, Mapping
 
 from unification import isvar, Var
@@ -22,6 +23,46 @@
 
 metatize_cache = {}
 
+_auto_reification_disabled = False
+_lvar_defaults_enabled = set()
+
+
+@contextmanager
+def disable_auto_reification():
+    """Stop meta objects from automatically reifying themselves in order to determine unspecified properties."""
+    global _auto_reification_disabled
+    _current_value = _auto_reification_disabled
+    _auto_reification_disabled = True
+    try:
+        yield
+    finally:
+        _auto_reification_disabled = _current_value
+
+
+@contextmanager
+def enable_lvar_defaults(*types):
+    """Use logic variables instead of guessed/inferred values during meta object creation.
+
+    This is useful for handling unexpected values--created by default or behind
+    the scenes--in backend base objects (e.g. default names, TF NodeDef
+    attributes, etc.).  By using logic variables instead, it's much easier to
+    create meta object "patterns" when certain types of exactness aren't
+    necessary.
+
+    Parameters
+    ----------
+      types: collection of str
+        String names for the types we want to make default to logic variables.
+        Currently allowed values are "names" and "node_attrs" (for TensorFlow).
+    """
+    global _lvar_defaults_enabled
+    _current_value = _lvar_defaults_enabled
+    _lvar_defaults_enabled = set(types)
+    try:
+        yield
+    finally:
+        _lvar_defaults_enabled = _current_value
+
 
 def metatize(obj):
     """Convert object to base type then meta object."""
@@ -107,6 +148,12 @@ def __new__(cls, name, bases, clsdict):
 
         if clsdict["__volatile_slots__"]:
 
+            def reset(self):
+                for s in self.__volatile_slots__:
+                    object.__setattr__(self, s, None)
+
+            clsdict["reset"] = reset
+
             def __setattr__(self, attr, obj):
                 """If a slot value is changed, reset cached slots."""
 
@@ -121,8 +168,7 @@ def __setattr__(self, attr, obj):
                     # Are we setting it to a new value?
                     and getattr(self, attr) is not obj
                 ):
-                    for s in self.__volatile_slots__:
-                        object.__setattr__(self, s, None)
+                    self.reset()
 
                 object.__setattr__(self, attr, obj)
 
@@ -150,6 +196,8 @@ def _cached_hash(self):
                 if getattr(self, "_hash", None) is not None:
                     return self._hash
 
+                # TODO: We could also descend into `__props__` and reset their
+                # `_hash` values, as well.
                 object.__setattr__(self, "_hash", _orig_hash(self))
 
                 return self._hash

symbolic_pymc/tensorflow/meta.py

@@ -8,7 +8,7 @@
 
 from inspect import Parameter, Signature
 
-from collections import OrderedDict
+from collections import OrderedDict, Sequence
 
 from functools import partial
 
@@ -35,6 +35,8 @@
     metatize,
 )
 
+from .. import meta
+
 
 class MetaOpDefLibrary(object):
 
@@ -164,6 +166,15 @@ def _metatize_tf_object(obj):
 
 def load_dispatcher():
     """Set/override dispatcher to default to TF objects."""
+
+    from tensorflow.python.ops.gen_linalg_ops import _SvdOutput
+
+    def _metatize_tf_svd(obj):
+        """Turn a TensorFlow `Svd` object/tuple into a standard tuple."""
+        return _metatize(tuple(obj))
+
+    _metatize.add((_SvdOutput,), _metatize_tf_svd)
+
     _metatize.add((object,), _metatize_tf_object)
 
 
@@ -207,6 +218,7 @@ class TFlowMetaOpDef(MetaOp, metaclass=OpDefFactoryType):
 
             >>> from google.protobuf import json_format
             >>> print(json_format.MessageToJson(opdef))
+
         - If you want to use an `OpDef` to construct a node, see
           `op_def_library.apply_op`.
 
@@ -220,39 +232,53 @@ def __init__(self, obj=None):
         self._apply_func_sig, self._apply_func = op_def_lib.get_op_info(obj)
 
     def out_meta_types(self, inputs=None, node_def=None):
+        """Return a list of tuples containing object types and corresponding dtypes for the outputs of this OpDef."""
+
         def _convert_outputs(o):
-            if o.type_attr == "T" and node_def:
+            if o.type_attr == "T" and hasattr(node_def, "attr"):
                 return (TFlowMetaTensor, node_def.attr.get("T", var()))
             elif o.type_attr == "dtype" and inputs:
                 return (TFlowMetaTensor, inputs.get("dtype", var()))
             else:
                 return (TFlowMetaTensor, var())
 
+        # TODO: We also have permissible dtype information from objects in the
+        # array `self.obj.attr` under the field `allowed_values`.
+
         out_meta_types = tuple(_convert_outputs(o) for o in self.obj.output_arg)
-        # TODO: We also have permissible dtype information:
-        # from objects in the array `self.obj.attr` under the field
-        # `allowed_values`.
+
         return out_meta_types
 
-    def input_args(self, *args, **kwargs):
+    def input_args(self, *args, apply_defaults=True, **kwargs):
+        """Return a list of arguments for this OpDef's 'apply function'."""
         kwargs = OrderedDict(
             (k, v)
             for k, v in kwargs.items()
             # Filter out the optional keyword arguments so they we only pass
             # expected arguments to the `OpDef`'s apply function.
             if k in self._apply_func_sig.parameters
         )
+
         op_args = self._apply_func_sig.bind(*args, **kwargs)
-        op_args.apply_defaults()
+
+        if apply_defaults:
+            op_args.apply_defaults()
+
         return op_args.arguments
 
     def __call__(self, *args, **kwargs):
         """Create the meta object(s) resulting from an application of this `OpDef`'s implied `Operation`."""
-        op_args, op_args_unreified = meta_reify_iter(args)
-        op_kwargs, op_kwargs_unreified = meta_reify_iter(kwargs)
+
+        if not meta._auto_reification_disabled:
+            op_args, op_args_unreified = meta_reify_iter(args)
+            op_kwargs, op_kwargs_unreified = meta_reify_iter(kwargs)
+        else:
+            op_args, op_args_unreified = args, True
+            op_kwargs, op_kwargs_unreified = kwargs, True
+
         apply_arguments = self.input_args(*op_args, **op_kwargs)
 
-        if not op_args_unreified and not op_kwargs_unreified:
+        if not (op_args_unreified or op_kwargs_unreified):
 
             # them into meta objects.  Doing so will yield information we
             # wouldn't be able to produce otherwise (e.g. shape info).
@@ -269,29 +295,43 @@ def __call__(self, *args, **kwargs):
 
             tf_out = self._apply_func(**apply_arguments)
             res_var = metatize(tf_out)
-            return res_var
-
-        #
-        # If we're here, that means we have to create the meta objects
-        # manually.
-        #
-        # TODO: `tf.placeholder`s are pretty flexible, we could probably use
-        # one as a stand-in for any un-reified tensor arguments and at least
-        # get some partial `dtype`, `shape` and `name` info.
-
-        op_input_args = tuple(
-            apply_arguments.get(i.name) for i in self.obj.input_arg if i.name in apply_arguments
-        )
 
-        node_attr = {a.name: apply_arguments.get(a.name, a) for a in self.obj.attr}
+            if "names" in meta._lvar_defaults_enabled:
+                # This should also reset the NodeDef's `obj`
+                res_var.op.node_def.name = var()
+                res_var.op.reset()
+                res_var.reset()
 
-        op_name = op_kwargs.get("name", self.obj.name)
+            if "node_attrs" in meta._lvar_defaults_enabled:
+                # This should also reset the NodeDef's `obj`
+                res_var.op.node_def.attr = var()
+                res_var.op.reset()
+                res_var.reset()
 
-        node_def = TFlowMetaNodeDef(self.obj.name, op_name, node_attr)
+        else:
+            #
+            # If we're here, that means we have to create the meta objects
+            # manually.
+            #
 
-        op_mt = TFlowMetaOp(self, node_def, op_input_args)
+            op_input_args = tuple(
+                apply_arguments.get(i.name) for i in self.obj.input_arg if i.name in apply_arguments
+            )
+
+            if "node_attrs" not in meta._lvar_defaults_enabled:
+                node_attr = {a.name: apply_arguments.get(a.name, a) for a in self.obj.attr}
+            else:
+                node_attr = var()
+
+            op_name = op_kwargs.get(
+                "name", self.obj.name if "names" not in meta._lvar_defaults_enabled else var()
+            )
+
+            node_def = TFlowMetaNodeDef(self.obj.name, op_name, node_attr)
 
-        res_var = op_mt.default_output
+            op_mt = TFlowMetaOp(self, node_def, op_input_args)
+
+            res_var = op_mt.default_output
 
         return res_var
 
@@ -517,16 +557,26 @@ def outputs(self):
         if getattr(self, "_outputs", None) is not None:
             return self._outputs
 
-        if (
-            isvar(self.op_def)
-            or isvar(self.inputs)
-            or isvar(self.node_def)
-            or isvar(self.node_def.attr)
-        ):
+        if isvar(self.op_def):
             self._outputs = var()
         else:
 
-            apply_arguments = self.op_def.input_args(*self.inputs, **self.node_def.attr)
+            if isvar(self.node_def) or isvar(getattr(self.node_def, "attr")):
+                node_attr = {}
+            else:
+                node_attr = self.node_def.attr
+
+            if isvar(self.inputs):
+                inputs = (None,) * len(self.op_def._apply_func_sig.parameters)
+                apply_defaults = False
+            else:
+                inputs = self.inputs
+                apply_defaults = True
+
+            apply_arguments = self.op_def.input_args(
+                *inputs, apply_defaults=apply_defaults, **node_attr
+            )
+
             out_types_mt = self.op_def.out_meta_types(
                 inputs=apply_arguments, node_def=self.node_def
             )
@@ -551,7 +601,7 @@ def default_output(self):
 
         mt_outs = self.outputs
 
-        if len(mt_outs) == 1:
+        if isinstance(mt_outs, Sequence) and len(mt_outs) == 1:
             out_var = mt_outs[0]
         else:
             out_var = mt_outs

tests/tensorflow/test_meta.py

@@ -14,7 +14,7 @@
 
 from unification import var, isvar
 
-from symbolic_pymc.meta import MetaSymbol
+from symbolic_pymc.meta import MetaSymbol, disable_auto_reification, enable_lvar_defaults
 from symbolic_pymc.tensorflow.meta import (TFlowMetaTensor,
                                            TFlowMetaTensorShape,
                                            TFlowMetaOp,
@@ -228,6 +228,13 @@ def test_meta_lvars():
     mo_mt = TFlowMetaOp(var(), var(), var(), var())
     assert all(isvar(getattr(mo_mt, s)) for s in mo_mt.__all_props__)
 
+    mo_mt = TFlowMetaOp(var(), var(), var())
+    assert isvar(mo_mt.op_def)
+    assert isvar(mo_mt.outputs)
+
+    mo_mt = TFlowMetaOp(mt.Add, var(), var())
+    assert len(mo_mt.outputs) == 1
+
     ts_mt = TFlowMetaTensorShape(var())
     assert all(isvar(getattr(ts_mt, s)) for s in ts_mt.__all_props__)
 
@@ -286,6 +293,13 @@ def test_meta_multi_output():
     assert d.op.outputs == (d, U, V)
     assert d.op.default_output is d.op.outputs
 
+    tf.compat.v1.disable_eager_execution()
+
+    X_mt = mt(np.eye(2))
+    d, U, V = mt.linalg.svd(X_mt)
+    d.value_index = var()
+    assert isinstance(d.reify(), TFlowMetaTensor)
+
 
 @pytest.mark.usefixtures("run_with_tensorflow")
 @run_in_graph_mode
@@ -515,3 +529,35 @@ def test_tensor_ops():
         abs_mt = abs(x_mt)
         assert abs_mt.name == abs_tf.name
         assert abs_mt.op.type == abs_tf.op.type
+
+
+@pytest.mark.usefixtures("run_with_tensorflow")
+@run_in_graph_mode
+def test_global_options():
+
+    with tf.Graph().as_default():
+        x_mt = mt.Placeholder('float')
+        assert isinstance(x_mt.obj, tf.Tensor)
+        assert x_mt.name == 'Placeholder:0'
+
+    with tf.Graph().as_default(), disable_auto_reification():
+        y_mt = mt.Placeholder('float')
+        assert y_mt.obj is None
+        assert y_mt.name == 'Placeholder:0'
+        assert isinstance(y_mt.op.node_def.attr, dict)
+
+    with tf.Graph().as_default(), enable_lvar_defaults('names', 'node_attrs'):
+        # This *will* auto-reify and have base versions of `names` and `attrs`;
+        # however, it will replace those with lvars.
+        z_mt = mt.Placeholder('float')
+        assert z_mt.obj is None
+        assert isvar(z_mt.name)
+        assert isvar(z_mt.op.node_def.attr)
+
+    with tf.Graph().as_default(), disable_auto_reification(), enable_lvar_defaults('names', 'node_attrs'):
+        # This will *not* auto-reify and simply create the object from scratch with meta types
+        # and the appropriate/desired logic variables.
+        z_mt = mt.Placeholder('float')
+        assert z_mt.obj is None
+        assert isvar(z_mt.name)
+        assert isvar(z_mt.op.node_def.attr)