def test_constant(self):
x = Constant(MyType(), 2, name="x")
y = MyVariable("y")
z = Constant(MyType(), 2, name="z")
e = op1(op1(x, y), y)
g = FunctionGraph([y], [e])
PatternOptimizer((op1, z, "1"), (op2, "1", z)).optimize(g)
assert str(g) == "FunctionGraph(Op1(Op2(y, z), y))"
def test_identical_constant_args(self):
x = MyVariable("x")
y = Constant(MyType(), 2, name="y")
z = Constant(MyType(), 2, name="z")
with config.change_flags(compute_test_value="off"):
e1 = op1(y, z)
g = FunctionGraph([x, y, z], [e1])
MergeOptimizer().optimize(g)
strg = str(g)
assert strg == "FunctionGraph(Op1(y, y))" or strg == "FunctionGraph(Op1(z, z))"
def test_constant_merging(self):
x = MyVariable("x")
y = Constant(MyType(), 2, name="y")
z = Constant(MyType(), 2, name="z")
e = op1(op2(x, y), op2(x, y), op2(x, z))
g = FunctionGraph([x, y, z], [e])
MergeOptimizer().optimize(g)
strg = str(g)
assert (strg == "FunctionGraph(Op1(*1 -> Op2(x, y), *1, *1))"
or strg == "FunctionGraph(Op1(*1 -> Op2(x, z), *1, *1))")
def test_identical_constant_args(self):
x = MyVariable("x")
y = Constant(MyType(), 2, name="y")
z = Constant(MyType(), 2, name="z")
e1 = op1(y, z)
g = FunctionGraph([x, y, z], [e1], clone=False)
MergeOptimizer().optimize(g)
assert g.outputs[0].owner.op == op1
input_1 = g.outputs[0].owner.inputs[0]
assert input_1 is g.outputs[0].owner.inputs[1]
def test_constant_merging(self):
x = MyVariable("x")
y = Constant(MyType(), 2, name="y")
z = Constant(MyType(), 2, name="z")
e = op1(op2(x, y), op2(x, y), op2(x, z))
g = FunctionGraph([x, y, z], [e], clone=False)
MergeOptimizer().optimize(g)
out_var = g.outputs[0]
var_1, var_2, var_3 = out_var.owner.inputs
assert var_1 is var_2
assert var_2 is var_3
def test_pre_greedy_local_optimizer():
empty_fgraph = FunctionGraph([], [])
x = MyVariable("x")
y = MyVariable("y")
c1 = Constant(MyType(), 1, "c1")
c2 = Constant(MyType(), 2, "c2")
o1 = op2(c1, c2)
o3 = op1(c1, y)
o2 = op1(o1, c2, x, o3, o1)
assert o2.owner.inputs[0].owner is not None
assert o2.owner.inputs[4].owner is not None
# This should fold `o1`, because it has only `Constant` arguments, and
# replace it with the `Constant` result
cst = pre_greedy_local_optimizer(empty_fgraph, [constant_folding], o2)
assert cst.owner.inputs[0].owner is None
assert cst.owner.inputs[1] is c2
assert cst.owner.inputs[2] is x
assert cst.owner.inputs[3] is o3
assert cst.owner.inputs[4] is cst.owner.inputs[0]
# We're going to do it again, except this time `o1` is
# in the `fgraph`, so it shouldn't be folded
fg = FunctionGraph([], [o1], clone=False)
o2 = op1(o1, c2, x, o3, o1)
cst = pre_greedy_local_optimizer(fg, [constant_folding], o2)
assert cst.owner.inputs[0] is o1
assert cst.owner.inputs[4] is cst.owner.inputs[0]
# What exactly is this supposed to test?
ms = MakeSlice()(1)
cst = pre_greedy_local_optimizer(empty_fgraph, [constant_folding], ms)
assert isinstance(cst, SliceConstant)
# Make sure constant of slice signature is hashable.
assert isinstance(hash(cst.signature()), int)
def test_pre_constant_merge():
empty_fgraph = FunctionGraph([], [])
x = MyVariable("x")
y = MyVariable("y")
c1 = Constant(MyType(), 1, "c1")
c2 = Constant(MyType(), 1, "c1")
o1 = op2(c1, x)
o2 = op1(o1, y, c2)
assert c1 is not c2
res = pre_constant_merge(empty_fgraph, [o2])
assert [o2] == res
assert o2.owner.inputs[2] is c1
o2 = op1(o1, y, c2)
fg = FunctionGraph([x, y], [o2], clone=False)
assert o2.owner in fg.apply_nodes
res = pre_constant_merge(fg, [o2])
assert res == [o2]
assert o2.owner.inputs[2] is c2
# What is this supposed to test?
ms = MakeSlice()(1)
res = pre_constant_merge(empty_fgraph, [ms])
assert res == [ms]
const_slice = SliceConstant(type=slicetype, data=slice(1, None, 2))
assert isinstance(const_slice, Constant)
adv = AdvancedSubtensor()(matrix(), [2, 3], const_slice)
res = pre_constant_merge(empty_fgraph, adv)
assert res == [adv]
def test_nominals(self):
t1 = MyType()
nm = NominalVariable(1, t1)
nm2 = NominalVariable(2, t1)
v1 = op1(nm, nm2)
fg = FunctionGraph(outputs=[v1], clone=False)
assert nm not in fg.inputs
assert nm2 not in fg.inputs
assert nm in fg.variables
assert nm2 in fg.variables
def make_node(self):
return Apply(self, [], [MyType()()])
def test_unify_Variable():
x_at = at.vector("x")
y_at = at.vector("y")
z_at = x_at + y_at
# `Variable`, `Variable`
s = unify(z_at, z_at)
assert s == {}
# These `Variable`s have no owners
v1 = MyType()()
v2 = MyType()()
assert v1 != v2
s = unify(v1, v2)
assert s is False
op_lv = var()
z_pat_et = etuple(op_lv, x_at, y_at)
# `Variable`, `ExpressionTuple`
s = unify(z_at, z_pat_et, {})
assert op_lv in s
assert s[op_lv] == z_at.owner.op
res = reify(z_pat_et, s)
assert isinstance(res, ExpressionTuple)
assert equal_computations([res.evaled_obj], [z_at])
z_et = etuple(at.add, x_at, y_at)
# `ExpressionTuple`, `ExpressionTuple`
s = unify(z_et, z_pat_et, {})
assert op_lv in s
assert s[op_lv] == z_et[0]
res = reify(z_pat_et, s)
assert isinstance(res, ExpressionTuple)
assert equal_computations([res.evaled_obj], [z_et.evaled_obj])
# `ExpressionTuple`, `Variable`
s = unify(z_et, x_at, {})
assert s is False
# This `Op` doesn't expand into an `ExpressionTuple`
op1_np = CustomOpNoProps(1)
q_at = op1_np(x_at, y_at)
a_lv = var()
b_lv = var()
# `Variable`, `ExpressionTuple`
s = unify(q_at, etuple(op1_np, a_lv, b_lv))
assert s[a_lv] == x_at
assert s[b_lv] == y_at
def make_node(self, *inputs):
outputs = [MyType()(), MyType()()]
return Apply(self, list(inputs), outputs)
