def test_Pipeline_configure(op_pipeline):
pdef = op_pipeline
pip = pdef.configure(addp=Merge(param=2)).make()
assert pip(value=3) == {'value': 100}
pip = pdef.configure({'addp.param': 2}).make()
assert pip(value=3) == {'value': 100}
pip = pdef.configure({
'addp.param': 2
}, addp=Merge(op=lambda p, x: p - x)).make()
assert pip(value=3) == {'value': 4}
pip = pdef.configure(addp=Reset(op=lambda p, x: p - x, param=2)).make()
assert pip(value=3) == {'value': 4}
with pytest.raises(TypeError):
pdef.configure(addp=Reset(param=2)).make()
pip = pdef.configure(mulp=False).make()
assert pip(value=3) == {'value': 16}
with pytest.raises(KeyError):
pip = pdef.configure(mulp=False).configure(mulp=True).make()
pip = pdef.configure(mulp=False).configure(addp=False).make()
assert pip(value=3) == {'value': 9}
with pytest.raises(KeyError):
pdef.configure(quack=[1, 2])
def pipeline(self, default=steps.standard, config=None):
if self.options['--scalar']:
resources = scalar_pipeline.resources
else:
resources = standard_pipeline.resources
all_steps = self.options['pipeline']
pos = [p for p in all_steps if not isinstance(p, Not)]
neg = {p.value for p in all_steps if isinstance(p, Not)}
if not pos:
pos = default
final = [p for p in pos if p not in neg]
pdef = PipelineDefinition(resources=resources,
steps={p._name: p
for p in final})
opts = self.options['opts']
if opts and steps.opt not in final:
raise Exception('Optimizations can only be applied if the'
' opt step is in the pipeline')
elif opts:
pdef = pdef.configure({'opt.opts': Merge(opts)})
if callable(config):
pdef = config(pdef)
elif config:
pdef = pdef.configure(config)
return pdef.make()
def test_merge_modes():
for x, y in [({1, 2}, {3, 4}), ([1, 2], [3, 4]), ((1, 2), (3, 4))]:
assert merge(x, y, mode="reset") == y
assert merge(x, Reset(y)) == y
assert merge(x, Reset(y), mode="merge") == y
assert merge(x, y, mode="override") == y
assert merge(x, Override(y)) == y
assert merge(x, Override(y), mode="merge") == y
a = {"a": 1}
b = {"b": 2}
c = {"a": 1, "b": 2}
assert merge(a, b, mode="reset") == b
assert merge(a, b, mode="override") == c
a = {"a": [1, 2], "b": [3, 4]}
b = {"a": [5, 6], "b": Override([7, 8])}
c = {"a": [1, 2, 5, 6], "b": [7, 8]}
d = {"a": [5, 6], "b": [7, 8]}
assert merge(a, b) == c
assert merge(a, b, mode="override") == d
a = {"a": [1, 2]}
assert merge(a, Merge(a=[3, 4])) == {"a": [1, 2, 3, 4]}
def test_Pipeline_configure(op_pipeline):
pdef = op_pipeline
pip = pdef.configure(addp=Merge(param=2)).make()
assert pip(value=3) == {'value': 100}
pip = pdef.configure({'addp.param': 2}).make()
assert pip(value=3) == {'value': 100}
pip = pdef.configure(
{'addp.param': 2},
addp=Merge(op=lambda p, x: p - x)
).make()
assert pip(value=3) == {'value': 4}
pip = pdef.configure(addp=Reset(op=lambda p, x: p - x, param=2)).make()
assert pip(value=3) == {'value': 4}
with pytest.raises(TypeError):
pdef.configure(addp=Reset(param=2)).make()
pip = pdef.configure(mulp=False).make()
assert pip(value=3) == {'value': 16}
pip = pdef.configure(mulp=False).configure(mulp=True).make()
assert pip(value=3) == {'value': 64}
pip = pdef.configure(mulp=False).configure(addp=False).make()
assert pip(value=3) == {'value': 9}
pip = pdef.configure(param=3).make()
assert pip(value=3) == {'value': 144}
with pytest.raises(KeyError):
pdef.configure(quack=[1, 2])
pdef2 = pdef.configure_resources(quack=[1, 2])
assert pdef2.make().resources.quack == [1, 2]
assert pdef2.configure(quack=Merge([3])).make().resources.quack \
== [1, 2, 3]
assert pdef2.configure(quack=[3]).make().resources.quack == [3]
from myia.pipeline import scalar_pipeline
from myia.prim import Primitive, ops as prim
from myia.utils import InferenceError, Merge
from myia.utils.unify import Var, var
from ..common import f64, i64, to_abstract_test
X = Var('X')
Y = Var('Y')
V = var(lambda n: n.is_constant())
parse = scalar_pipeline \
.configure({
'resources.convert.object_map': Merge({
operations.getitem: prim.tuple_getitem,
operations.user_switch: prim.switch
})
}) \
.select('resources', 'parse', 'resolve') \
.make_transformer('input', 'graph')
specialize = scalar_pipeline \
.configure({
'resources.convert.object_map': Merge({
operations.getitem: prim.tuple_getitem
})
}) \
.select('resources', 'parse', 'resolve', 'infer', 'specialize')
# We will optimize patterns of these fake primitives
def test_cleanup_subclass():
a = TypeMap({int: Merge("int")})
ca = cleanup(a)
assert isinstance(ca, TypeMap)
assert ca == TypeMap({int: "int"})
def test_cleanup():
a = dict(a=1, b=[2, Merge(3)], c=Override(4), d=DELETE)
assert cleanup(a) == dict(a=1, b=[2, 3], c=4)
cse, NodeMap
from myia.prim import Primitive, ops as prim
from myia.utils import Merge
from myia.utils.unify import Var, var
from ..common import i64, f64, to_abstract_test
X = Var('X')
Y = Var('Y')
V = var(lambda n: n.is_constant())
parse = scalar_pipeline \
.configure({
'convert.object_map': Merge({operations.getitem: prim.tuple_getitem})
}) \
.select('parse', 'resolve') \
.make_transformer('input', 'graph')
specialize = scalar_pipeline \
.configure({
'convert.object_map': Merge({operations.getitem: prim.tuple_getitem})
}) \
.select('parse', 'resolve', 'infer', 'specialize')
# We will optimize patterns of these fake primitives
from myia.testing.common import i64, to_abstract_test
from myia.utils import InferenceError, Merge
from myia.utils.unify import Var, var
from myia.validate import ValidationError
X = Var("X")
Y = Var("Y")
V = var(lambda n: n.is_constant())
parse = (
scalar_pipeline.configure(
{
"convert.object_map": Merge(
{
operations.getitem: prim.tuple_getitem,
operations.user_switch: prim.switch,
}
),
}
)
.with_steps(steps.step_parse, steps.step_copy)
.make_transformer("input", "graph")
)
specialize = scalar_pipeline.configure(
{"convert.object_map": Merge({operations.getitem: prim.tuple_getitem})}
).with_steps(steps.step_parse, steps.step_infer, steps.step_specialize)
# We will optimize patterns of these fake primitives
)
from myia.pipeline import scalar_pipeline, steps
from myia.utils import InferenceError, Merge
from myia.utils.unify import Var, var
from myia.validate import ValidationError
from ..common import i64, to_abstract_test
X = Var("X")
Y = Var("Y")
V = var(lambda n: n.is_constant())
parse = (scalar_pipeline.configure({
"resources.convert.object_map":
Merge({
operations.getitem: prim.tuple_getitem,
operations.user_switch: prim.switch,
})
}).select("resources", "parse", {
"resolve": steps.step_resolve
}).make_transformer("input", "graph"))
specialize = scalar_pipeline.configure({
"resources.convert.object_map":
Merge({operations.getitem: prim.tuple_getitem})
}).select("resources", "parse", {"resolve": steps.step_resolve}, "infer",
"specialize")
# We will optimize patterns of these fake primitives
P = Primitive("P")
Q = Primitive("Q")
