Merge pull request #98 from brandonwillard/updates-for-kanren-v1

Updates for miniKanren package v1

Author: brandonwillard

requirements.txt

@@ -1,4 +1,5 @@
 -e ./
+sympy>=1.3
 coveralls
 pydocstyle>=3.0.0
 pytest>=5.0.0

setup.py

@@ -36,14 +36,15 @@ def get_long_description():
         "Theano>=1.0.4",
         "tf-nightly-2.0-preview==2.0.0.dev20191002",
         "tf-nightly==2.1.0.dev20191003",
-        "tensorflow-estimator-2.0-preview>=1.14.0.dev2019090801",
+        "tf-estimator-nightly==2.0.0.dev2019100301",
+        "tensorflow-estimator-2.0-preview==1.14.0.dev2019090801",
         "tfp-nightly==0.9.0.dev20191003",
         "multipledispatch>=0.6.0",
-        "logical-unification>=0.2.2",
-        "miniKanren>=0.4.0",
-        "cons>=0.1.3",
+        "logical-unification>=0.4.3",
+        "miniKanren>=1.0.1",
+        "etuples>=0.3.1",
+        "cons>=0.4.0",
         "toolz>=0.9.0",
-        "sympy>=1.3",
         "cachetools",
         "pymc3>=3.6",
         "pymc4 @ git+https://github.com/pymc-devs/pymc4.git@master#egg=pymc4-0.0.1",

symbolic_pymc/relations/__init__.py

@@ -1,9 +1,3 @@
-from itertools import tee, chain
-from functools import reduce
-
-from toolz import interleave
-
-from kanren.core import goaleval
 from kanren.facts import Relation
 
 from unification import unify, reify, Var
@@ -34,58 +28,3 @@ def concat_goal(S):
             yield S
 
     return concat_goal
-
-
-def ldisj_seq(goals):
-    """Produce a goal that returns the appended state stream from all successful goal arguments.
-
-    In other words, it behaves like logical disjunction/OR for goals.
-    """
-
-    def ldisj_seq_goal(S):
-        nonlocal goals
-
-        goals, _goals = tee(goals)
-
-        yield from interleave(goaleval(g)(S) for g in _goals)
-
-    return ldisj_seq_goal
-
-
-def lconj_seq(goals):
-    """Produce a goal that returns the appended state stream in which all goals are necessarily successful.
-
-    In other words, it behaves like logical conjunction/AND for goals.
-    """
-
-    def lconj_seq_goal(S):
-        nonlocal goals
-
-        goals, _goals = tee(goals)
-
-        g0 = next(iter(_goals), None)
-
-        if g0 is None:
-            return
-
-        z0 = goaleval(g0)(S)
-
-        yield from reduce(lambda z, g: chain.from_iterable(map(goaleval(g), z)), _goals, z0)
-
-    return lconj_seq_goal
-
-
-def ldisj(*goals):
-    return ldisj_seq(goals)
-
-
-def lconj(*goals):
-    return lconj_seq(goals)
-
-
-def conde(*goals):
-    return ldisj_seq(lconj_seq(g) for g in goals)
-
-
-lall = lconj
-lany = ldisj

symbolic_pymc/theano/printing.py

@@ -10,8 +10,19 @@
 
 from theano import gof
 
-from sympy import Array as SympyArray
-from sympy.printing import latex as sympy_latex
+try:
+    from sympy import Array as SympyArray
+    from sympy.printing import latex as sympy_latex
+
+    def latex_print_array(data):  # pragma: no cover
+        return sympy_latex(SympyArray(data))
+
+
+except ImportError:  # pragma: no cover
+
+    def latex_print_array(data):
+        return data
+
 
 from .opt import FunctionGraph
 from .ops import RandomVariable
@@ -60,16 +71,16 @@ def process_param(self, idx, sform, pstate):
             The printer state.
 
         """
-        return sform
+        return sform  # pragma: no cover
 
     def process(self, output, pstate):
         if output in pstate.memo:
             return pstate.memo[output]
 
         pprinter = pstate.pprinter
-        node = output.owner
+        node = getattr(output, "owner", None)
 
-        if node is None or not isinstance(node.op, RandomVariable):
+        if node is None or not isinstance(node.op, RandomVariable):  # pragma: no cover
             raise TypeError(
                 "Function %s cannot represent a variable that is "
                 "not the result of a RandomVariable operation" % self.name
@@ -78,7 +89,7 @@ def process(self, output, pstate):
         op_name = self.name or getattr(node.op, "print_name", None)
         op_name = op_name or getattr(node.op, "name", None)
 
-        if op_name is None:
+        if op_name is None:  # pragma: no cover
             raise ValueError(f"Could not find a name for {node.op}")
 
         # Allow `Op`s to specify their ascii and LaTeX formats (in a tuple/list
@@ -144,7 +155,7 @@ def process(self, output, pstate):
 
 class GenericSubtensorPrinter(object):
     def process(self, r, pstate):
-        if r.owner is None:
+        if getattr(r, "owner", None) is None:  # pragma: no cover
             raise TypeError("Can only print Subtensor.")
 
         output_latex = getattr(pstate, "latex", False)
@@ -161,13 +172,13 @@ def process(self, r, pstate):
                 if isinstance(entry, slice):
                     s_parts = [""] * 2
                     if entry.start is not None:
-                        s_parts[0] = entry.start
+                        s_parts[0] = pstate.pprinter.process(inputs.pop())
 
                     if entry.stop is not None:
-                        s_parts[1] = entry.stop
+                        s_parts[1] = pstate.pprinter.process(inputs.pop())
 
                     if entry.step is not None:
-                        s_parts.append(entry.stop)
+                        s_parts.append(pstate.pprinter.process(inputs.pop()))
 
                     sidxs.append(":".join(s_parts))
                 else:
@@ -215,16 +226,22 @@ def process(cls, output, pstate):
         using_latex = getattr(pstate, "latex", False)
         # Crude--but effective--means of stopping print-outs for large
         # arrays.
-        constant = isinstance(output, tt.TensorConstant)
+        constant = isinstance(output, (tt.TensorConstant, theano.scalar.basic.ScalarConstant))
         too_large = constant and (output.data.size > cls.max_line_width * cls.max_line_height)
 
         if constant and not too_large:
             # Print constants that aren't too large
             if using_latex and output.ndim > 0:
-                out_name = sympy_latex(SympyArray(output.data))
+                out_name = latex_print_array(output.data)
             else:
                 out_name = str(output.data)
-        elif isinstance(output, tt.TensorVariable) or constant:
+        elif (
+            isinstance(
+                output,
+                (tt.TensorVariable, theano.scalar.basic.Scalar, theano.scalar.basic.ScalarVariable),
+            )
+            or constant
+        ):
             # Process name and shape
 
             # Attempt to get the original variable, in case this is a cloned
@@ -238,7 +255,7 @@ def process(cls, output, pstate):
 
             shape_strings = pstate.preamble_dict.setdefault("shape_strings", OrderedDict())
             shape_strings[output] = shape_info
-        else:
+        else:  # pragma: no cover
             raise TypeError(f"Type {type(output)} not handled by variable printer")
 
         pstate.memo[output] = out_name
@@ -268,7 +285,7 @@ def process_variable_name(cls, output, pstate):
                 _ = [available_names.pop(v.name, None) for v in fgraph.variables]
             setattr(pstate, "available_names", available_names)
 
-        if output.name:
+        if getattr(output, "name", None):
             # Observed an existing name; remove it.
             out_name = output.name
             available_names.pop(out_name, None)
@@ -524,11 +541,18 @@ def __call__(self, *args, latex_env="equation", latex_label=None):
 
 # The order here is important!
 tt_pprint.printers.insert(
-    0, (lambda pstate, r: isinstance(r, tt.Variable), VariableWithShapePrinter)
+    0,
+    (
+        lambda pstate, r: isinstance(r, (theano.scalar.basic.Scalar, tt.Variable)),
+        VariableWithShapePrinter,
+    ),
 )
 tt_pprint.printers.insert(
     0,
-    (lambda pstate, r: r.owner and isinstance(r.owner.op, RandomVariable), RandomVariablePrinter()),
+    (
+        lambda pstate, r: getattr(r, "owner", None) and isinstance(r.owner.op, RandomVariable),
+        RandomVariablePrinter(),
+    ),
 )
 
 
@@ -538,9 +562,9 @@ def process(self, output, pstate):
             return pstate.memo[output]
 
         pprinter = pstate.pprinter
-        node = output.owner
+        node = getattr(output, "owner", None)
 
-        if node is None or not isinstance(node.op, Observed):
+        if node is None or not isinstance(node.op, Observed):  # pragma: no cover
             raise TypeError(f"Node Op is not of type `Observed`: {node.op}")
 
         val = node.inputs[0]

symbolic_pymc/unify.py

@@ -5,9 +5,8 @@
 
 from kanren.term import arguments, operator
 
-from unification.more import unify
 from unification.variable import Var
-from unification.core import _reify, _unify, reify
+from unification.core import _reify, _unify, reify, unify
 
 from etuples import etuple
 

tests/test_relations.py

@@ -1,8 +1,8 @@
 from unification import var
 
-from kanren import eq, run
+from kanren import run
 
-from symbolic_pymc.relations import lconj, lconj_seq, ldisj, ldisj_seq, conde, concat
+from symbolic_pymc.relations import concat
 
 
 def test_concat():
@@ -11,81 +11,3 @@ def test_concat():
     assert not run(0, q, concat("a", "b", "bc"))
     assert not run(0, q, concat(1, "b", "bc"))
     assert run(0, q, concat(q, "b", "bc")) == (q,)
-
-
-def test_lconj_basics():
-
-    res = list(lconj(eq(1, var("a")), eq(2, var("b")))({}))
-    assert res == [{var("a"): 1, var("b"): 2}]
-
-    res = list(lconj(eq(1, var("a")))({}))
-    assert res == [{var("a"): 1}]
-
-    res = list(lconj_seq([])({}))
-    assert res == []
-
-    res = list(lconj(eq(1, var("a")), eq(2, var("a")))({}))
-    assert res == []
-
-    res = list(lconj(eq(1, 2))({}))
-    assert res == []
-
-    res = list(lconj(eq(1, 1))({}))
-    assert res == [{}]
-
-
-def test_ldisj_basics():
-
-    res = list(ldisj(eq(1, var("a")))({}))
-    assert res == [{var("a"): 1}]
-
-    res = list(ldisj(eq(1, 2))({}))
-    assert res == []
-
-    res = list(ldisj(eq(1, 1))({}))
-    assert res == [{}]
-
-    res = list(ldisj(eq(1, var("a")), eq(1, var("a")))({}))
-    assert res == [{var("a"): 1}, {var("a"): 1}]
-
-    res = list(ldisj(eq(1, var("a")), eq(2, var("a")))({}))
-    assert res == [{var("a"): 1}, {var("a"): 2}]
-
-    res = list(ldisj_seq([])({}))
-    assert res == []
-
-
-def test_conde_basics():
-
-    res = list(conde([eq(1, var("a")), eq(2, var("b"))], [eq(1, var("b")), eq(2, var("a"))])({}))
-    assert res == [{var("a"): 1, var("b"): 2}, {var("b"): 1, var("a"): 2}]
-
-    res = list(conde([eq(1, var("a")), eq(2, 1)], [eq(1, var("b")), eq(2, var("a"))])({}))
-    assert res == [{var("b"): 1, var("a"): 2}]
-
-    res = list(
-        conde(
-            [eq(1, var("a")), conde([eq(11, var("aa"))], [eq(12, var("ab"))])],
-            [
-                eq(1, var("b")),
-                conde([eq(111, var("ba")), eq(112, var("bb"))], [eq(121, var("bc"))]),
-            ],
-        )({})
-    )
-    assert res == [
-        {var("a"): 1, var("aa"): 11},
-        {var("b"): 1, var("ba"): 111, var("bb"): 112},
-        {var("a"): 1, var("ab"): 12},
-        {var("b"): 1, var("bc"): 121},
-    ]
-
-    res = list(conde([eq(1, 2)], [eq(1, 1)])({}))
-    assert res == [{}]
-
-    assert list(lconj(eq(1, 1))({})) == [{}]
-
-    res = list(lconj(conde([eq(1, 2)], [eq(1, 1)]))({}))
-    assert res == [{}]
-
-    res = list(lconj(conde([eq(1, 2)], [eq(1, 1)]), conde([eq(1, 2)], [eq(1, 1)]))({}))
-    assert res == [{}]

tests/theano/test_kanren.py

@@ -74,7 +74,7 @@ def test_kanren():
     Y_mt = mt.MvNormalRV(E_y_mt, V_lv, y_size_lv, y_rng_lv, name=y_name_lv)
 
     with variables(Y_mt):
-        (res,) = run(0, Y_mt, (eq, Y_rv, Y_mt))
+        (res,) = run(0, Y_mt, eq(Y_rv, Y_mt))
     assert res.reify() == Y_rv
 
 

tests/theano/test_opt.py

@@ -4,7 +4,7 @@
 from unification import var
 
 from kanren import eq
-from kanren.core import lallgreedy
+from kanren.core import lall
 
 from etuples import etuple, etuplize
 
@@ -36,13 +36,11 @@ def test_kanren_opt():
     assert isinstance(fgraph.outputs[0].owner.op, tt.Dot)
 
     def distributes(in_lv, out_lv):
-        return (
-            lallgreedy,
+        return lall(
             # lhs == A * (x + b)
-            (eq, etuple(mt.dot, var("A"), etuple(mt.add, var("x"), var("b"))), etuplize(in_lv)),
+            eq(etuple(mt.dot, var("A"), etuple(mt.add, var("x"), var("b"))), etuplize(in_lv)),
             # rhs == A * x + A * b
-            (
-                eq,
+            eq(
                 etuple(
                     mt.add, etuple(mt.dot, var("A"), var("x")), etuple(mt.dot, var("A"), var("b"))
                 ),