def test_aliasing_list(): from myia.compile.backends import LoadingError, load_backend try: load_backend('pytorch') except LoadingError: pytest.skip('PyTorch not available') def g(xs, y): res = 0 for x in xs: res = res + x return sum(res) @myia(backend='pytorch', alias_tracker=ndarray_aliasable) def f(xs, y): return grad(g)(xs, y) o = np.ones((1, 3)) a = o * 3 b = o * 4 c = o * 5 d = o * 6 e = o * 7 res1 = f([a, b, c, d], e) for x in res1: np.testing.assert_allclose(x, o) with pytest.raises(MyiaInputTypeError): print(f([a, b, c, a], e)) with pytest.raises(MyiaInputTypeError): print(f([a, b, c, d], a))
def __init__(self, backend, backend_options): try: load_backend(backend) except LoadingError as e: pytest.skip(f"Can't load {backend}: {e.__cause__}") self.pip = standard_pipeline.configure({ 'compile.backend': backend, 'compile.backend_options': backend_options }).make()
def test_backend_error(): from myia.compile.backends import _backends, register_backend name = '__testing_name000_' def f(): raise ValueError('test') register_backend(name, f) with pytest.raises(LoadingError): load_backend(name) del _backends[name]
def test_backend_error(): from myia.compile.backends import _backends, register_backend name = "__testing_name000_" def format(): return {} def f(): raise ValueError("test") register_backend(name, f, format) with pytest.raises(LoadingError): load_backend(name) del _backends[name]
def __init__(self, backend, backend_options): try: self.backend = load_backend(backend, backend_options) except LoadingError as e: pytest.skip(f"Can't load {backend}: {e.__cause__}") self.pip = standard_pipeline.configure({ 'resources.backend.name': backend, 'resources.backend.options': backend_options }).make()
def wrapper_fn(*args, **kwargs): if primitives: backend = kwargs["backend"] bck = load_backend(backend) for prim_group in primitives: if not bck.supports_prim_group(prim_group): pytest.skip( f"Backend {backend} does not support {prim_group}") return fn(*args, **kwargs)
def test_load_backend_unknown(): with pytest.raises(UnknownBackend): load_backend('_fake_name_')
from dataclasses import dataclass import pytest from myia import myia from myia.compile.backends import load_backend from myia.lib import Empty, HandleInstance, core from myia.operations import cell_get, cell_set, make_cell from myia.pipeline import standard_pipeline, steps try: load_backend("relay") except Exception: pytestmark = pytest.mark.skip("Requires relay") upipeline = standard_pipeline.insert_after("parse", resolve=steps.step_resolve) umyia = myia( use_universe=True, backend="relay", backend_options={"exec_kind": "debug"}, pipeline=upipeline, ) def add_one(x): # Not universal, but should work from universal function return x + 1
def safe_load(name): try: return load_backend(name) except LoadingError: return None
def _run( self, fn, args, result=None, abstract=None, broad_specs=None, validate=True, pipeline=standard_pipeline, backend=None, numpy_compat=False, primitives=None, **kwargs, ): """Test a Myia function. Arguments: self: auto-passed MyiaFunctionTest object. fn: The Myia function to test. args: The args for the function. result: The expected result, or an exception subclass. If result is None, we will call the Python version of the function to compare with. abstract: The argspec. If None, it will be derived automatically from the args. broad_specs: For each argument, whether to broaden the type. By default, broaden all arguments. validate: Whether to run the validation step. pipeline: The pipeline to use. backend: backends to use. Tuple (backend name, backend options) numpy_compat: if True, check if args can be converted to numpy arrays. primitives: optional list of primitives or groups of primitives (as PrimGroup objects) required for this test. If a backend does not support any of given primitives or groups, then related test is explicitly skipped. """ if backend: backend_name = backend[0] backend_options = backend[1] if primitives: b = load_backend(backend_name, backend_options) for p in primitives: g = PrimGroup.ensure(p) if not b.supports_prim_group(g): pytest.skip(f"Backend {backend_name} does not support {g}") pipeline = pipeline.configure({ "backend.name": backend_name, "backend.options": backend_options }) if abstract is None: if broad_specs is None: broad_specs = (True, ) * len(args) argspec = tuple( from_value(arg, broaden=bs) for bs, arg in zip(broad_specs, args)) else: argspec = tuple(to_abstract_test(a) for a in abstract) if not validate: pipeline = pipeline.configure(validator=None) def out(args): mfn = pipeline(input=fn, argspec=argspec) rval = mfn["output"](*args) return rval if result is None: result = fn(*args) self.check(out, args, result, **kwargs) if numpy_compat: args_torch = args args = () for _ in args_torch: args += (to_numpy(_), ) if abstract is None: if broad_specs is None: broad_specs = (True, ) * len(args) argspec = tuple( from_value(arg, broaden=bs) for bs, arg in zip(broad_specs, args)) else: argspec = tuple(to_abstract_test(a) for a in abstract) out(args)
import pytest from myia import myia from myia.compile.backends import load_backend from myia.lib import Empty, HandleInstance, core from myia.operations import handle, handle_get, handle_set try: load_backend('relay') except Exception: pytestmark = pytest.mark.skip('Requires relay') def add_one(x): # Not universal, but should work from universal function return x + 1 @core(use_universe=True) def increment(h): return handle_set(h, add_one(handle_get(h))) def test_increment(): @myia(use_universe=True, backend='relay') def plus4(x): h = handle(x) increment(h) increment(h) increment(h) increment(h)