def test_fn(): res = TestResource() def f(y): return res.x + y opts = converter.ConversionOptions(recursive=True) api.converted_call(f, None, opts, (1,), {})
def test_converted_call_builtin(self): x = api.converted_call(range, None, converter.ConversionOptions(recursive=True), (3,), {}) self.assertEqual((0, 1, 2), tuple(x)) x = api.converted_call('compile', re, converter.ConversionOptions(recursive=True), ('mnas_v4_a.*\\/.*(weights|kernel):0$',), {}) self.assertIsNotNone(x.match('mnas_v4_a/weights:0'))
def test_fn(): res = TestResource() def f(y): def inner_f(): return res.x + y return inner_f opts = converter.ConversionOptions() api.converted_call(f, None, opts, (1,), {})()
def test_converted_call_already_converted(self): def f(x): return x == 0 x = api.converted_call(f, None, converter.ConversionOptions(), (constant_op.constant(0),), {}) self.assertTrue(self.evaluate(x)) converted_f = api.to_graph(f) x = api.converted_call(converted_f, None, converter.ConversionOptions(), (constant_op.constant(0),), {}) self.assertTrue(self.evaluate(x))
def test_converted_call_already_converted(self): def f(x): return x == 0 with self.cached_session() as sess: x = api.converted_call(f, None, converter.ConversionOptions(), constant_op.constant(0)) self.assertTrue(sess.run(x)) converted_f = api.to_graph(f) x = api.converted_call(converted_f, None, converter.ConversionOptions(), constant_op.constant(0)) self.assertTrue(sess.run(x))
def test_converted_call_already_converted(self): def f(x): return x == 0 with self.test_session() as sess: x = api.converted_call(f, False, False, False, {}, constant_op.constant(0)) self.assertTrue(sess.run(x)) converted_f = api.to_graph(f) x = api.converted_call(converted_f, False, False, False, {}, constant_op.constant(0)) self.assertTrue(sess.run(x))
def test_converted_call_already_converted(self): def f(x): return x == 0 x = api.converted_call(f, None, converter.ConversionOptions(recursive=True), (constant_op.constant(0),), {}) self.assertTrue(self.evaluate(x)) converted_f = api.to_graph( f, experimental_optional_features=converter.Feature.ALL) x = api.converted_call(converted_f, None, converter.ConversionOptions(recursive=True), (constant_op.constant(0),), {}) self.assertTrue(self.evaluate(x))
def test_converted_call_no_user_code(self): def f(x): return len(x) opts = converter.ConversionOptions(internal_convert_user_code=False) # f should not be converted, causing len to error out. with self.assertRaisesRegexp(Exception, 'object of type \'Tensor\' has no len()'): api.converted_call(f, None, opts, constant_op.constant([0])) # len on the other hand should work fine. x = api.converted_call(len, None, opts, constant_op.constant([0])) # The constant has static shape so the result is a primitive not a Tensor. self.assertEqual(x, 1)
def test_converted_call_numpy(self): opts = converter.ConversionOptions(recursive=True) x = api.converted_call(np.arange, None, opts, (5,), {}) self.assertAllEqual(x, list(range(5)))
def test_converted_call_namedtuple(self): opts = converter.ConversionOptions() x = api.converted_call(collections.namedtuple, None, opts, ('TestNamedtuple', ('a', 'b')), {}) self.assertTrue(inspect_utils.isnamedtuple(x))
def test_converted_call_functools_partial(self): def test_fn(x, y, z): if x < 0: return -x, -y, -z return x, y, z x = api.converted_call( functools.partial(test_fn, constant_op.constant(-1), z=-3), None, converter.ConversionOptions(), (constant_op.constant(-2),), {}) self.assertEqual((1, 2, 3), self.evaluate(x)) x = api.converted_call( functools.partial( functools.partial(test_fn, constant_op.constant(-1)), z=-3), None, converter.ConversionOptions(), (constant_op.constant(-2),), {}) self.assertEqual((1, 2, 3), self.evaluate(x))
def test_converted_call_namedtuple_via_collections(self): opts = converter.ConversionOptions(recursive=True) x = api.converted_call('namedtuple', collections, opts, ('TestNamedtuple', ('a', 'b')), {}) self.assertTrue(inspect_utils.isnamedtuple(x))
def test_converted_call_tf_op_forced(self): # TODO(mdan): Add the missing level of support to LOGICAL_EXPRESSIONS. opts = converter.ConversionOptions( force_conversion=True, optional_features=None) x = api.converted_call(gen_math_ops.add, None, opts, (1, 1), {}) self.assertAllEqual(self.evaluate(x), 2)
def test_converted_call_no_kwargs_allowed(self): def f(*args): # Note: np.broadcast rejects any **kwargs, even *{} return np.broadcast(args[:1]) opts = converter.ConversionOptions(internal_convert_user_code=False) self.assertIsNotNone(api.converted_call(f, None, opts, (1, 2, 3, 4), None))
def test_converted_call_function(self): def test_fn(x): if x < 0: return -x return x x = api.converted_call(test_fn, None, converter.ConversionOptions(), (constant_op.constant(-1),), {}) self.assertEqual(1, self.evaluate(x))
def test_converted_call_lambda(self): opts = converter.ConversionOptions(recursive=True) l = lambda x: x == 0 x = api.converted_call(l, None, opts, (constant_op.constant(0),), {}) self.evaluate(variables.global_variables_initializer()) self.assertAllEqual(True, self.evaluate(x))
def test_converted_call_function(self): def test_fn(x): if x < 0: return -x return x with self.cached_session() as sess: x = api.converted_call(test_fn, None, converter.ConversionOptions(), constant_op.constant(-1)) self.assertEqual(1, sess.run(x))
def test_converted_call_lambda(self): opts = converter.ConversionOptions() l = lambda x: x == 0 x = api.converted_call(l, None, opts, constant_op.constant(0)) with self.cached_session() as sess: sess.run(variables.global_variables_initializer()) self.assertAllEqual(True, sess.run(x))
def test_converted_call_function(self): def test_fn(x): if x < 0: return -x return x with self.test_session() as sess: x = api.converted_call(test_fn, False, False, False, {}, constant_op.constant(-1)) self.assertEqual(1, sess.run(x))
def test_converted_call_exec_generated_code(self): temp_mod = imp.new_module('test_module') dynamic_code = ''' def foo(x): return x + 1 ''' exec(textwrap.dedent(dynamic_code), temp_mod.__dict__) # pylint:disable=exec-used opts = converter.ConversionOptions(optional_features=None) x = api.converted_call(temp_mod.foo, None, opts, (1,), {}) self.assertAllEqual(x, 2)
def test_converted_call_whitelisted_method_via_owner(self): opts = converter.ConversionOptions(recursive=True) model = sequential.Sequential([ core.Dense(2) ]) x = api.converted_call('call', model, opts, (constant_op.constant([[0.0]]),), {'training': True}) self.evaluate(variables.global_variables_initializer()) self.assertAllEqual([[0.0, 0.0]], self.evaluate(x))
def test_converted_call_whitelisted_method_via_owner(self): opts = converter.ConversionOptions() model = sequential.Sequential([ core.Dense(2) ]) x = api.converted_call('call', model, opts, constant_op.constant([[0.0]]), training=True) with self.cached_session() as sess: sess.run(variables.global_variables_initializer()) self.assertAllEqual([[0.0, 0.0]], sess.run(x))
def test_converted_call_method_wrapper(self): class TestClass(object): def foo(self): pass tc = TestClass() # `method.__get__()` returns a so-called method-wrapper. wrapper = api.converted_call('__get__', tc.foo, converter.ConversionOptions(recursive=True), (tc,), {}) self.assertEqual(wrapper, tc.foo)
def test_converted_call_mangled_properties(self): class TestClass(object): def __init__(self): self.__private = constant_op.constant(-1) def test_method(self): return self.__private tc = TestClass() with self.assertRaisesRegex(errors.UnsupportedLanguageElementError, 'mangled names'): api.converted_call(tc.test_method, (), None, options=DEFAULT_RECURSIVE) # TODO(mdan): Refactor to avoid this use of global state. ag_logging.set_verbosity(0, True) os.environ['AUTOGRAPH_STRICT_CONVERSION'] = '0' with self.assertPrints('could not transform', 'bug'): api.converted_call(tc.test_method, (), None, options=DEFAULT_RECURSIVE) ag_logging.set_verbosity(0, False) os.environ['AUTOGRAPH_STRICT_CONVERSION'] = '1'
def test_converted_call_functools_partial_kwarg_mutation(self): def test_fn(x, y, z): if x < 0: return -x, -y, -z return x, y, z partial_fn = functools.partial(test_fn, constant_op.constant(-1), z=-3) # Call using kwargs to assign y first to ensure that partial_fn.keywords is # not mutated for subsequent calls (where y is assign through args). x = api.converted_call( partial_fn, args=(), kwargs={ 'y': constant_op.constant(-2), }, options=DEFAULT_RECURSIVE) self.assertEqual((1, 2, 3), self.evaluate(x)) x = api.converted_call( partial_fn, args=(constant_op.constant(-4),), kwargs=None, options=DEFAULT_RECURSIVE) self.assertEqual((1, 4, 3), self.evaluate(x))
def test_converted_call_whitelisted_method_via_owner(self): opts = converter.ConversionOptions() model = sequential.Sequential([core.Dense(2)]) x = api.converted_call('call', model, opts, constant_op.constant([[0.0]]), training=True) with self.cached_session() as sess: self.evaluate(variables.global_variables_initializer()) self.assertAllEqual([[0.0, 0.0]], self.evaluate(x))
def test_converted_call_callable_object(self): class TestClass(object): def __init__(self, x): self.x = x def __call__(self): if self.x < 0: return -self.x return self.x tc = TestClass(constant_op.constant(-1)) x = api.converted_call(tc, None, converter.ConversionOptions(), (), {}) self.assertEqual(1, self.evaluate(x))
def test_converted_call_method_by_class(self): class TestClass(object): def __init__(self, x): self.x = x def test_method(self): if self.x < 0: return -self.x return self.x tc = TestClass(constant_op.constant(-1)) x = api.converted_call(TestClass.test_method, (tc, ), None, options=DEFAULT_RECURSIVE) self.assertEqual(1, self.evaluate(x))
def test_converted_call_callable_object(self): class TestClass(object): def __init__(self, x): self.x = x def __call__(self): if self.x < 0: return -self.x return self.x tc = TestClass(constant_op.constant(-1)) x = api.converted_call(tc, None, converter.ConversionOptions(recursive=True), (), {}) self.assertEqual(1, self.evaluate(x))
def test_converted_call_then_already_converted_dynamic(self): @api.convert() def g(x): if x > 0: return x else: return -x def f(g, x): return g(x) x = api.converted_call(f, None, converter.ConversionOptions(recursive=True), (g, constant_op.constant(1)), {}) self.assertEqual(self.evaluate(x), 1)
def test_converted_call_then_already_converted_dynamic(self): @api.convert() def g(x): if x > 0: return x else: return -x def f(g, x): return g(x) x = api.converted_call(f, converter.ConversionOptions(recursive=True), (g, constant_op.constant(1)), {}) self.assertEqual(self.evaluate(x), 1)
def test_converted_call_method_by_class(self): class TestClass(object): def __init__(self, x): self.x = x def test_method(self): if self.x < 0: return -self.x return self.x tc = TestClass(constant_op.constant(-1)) x = api.converted_call(TestClass.test_method, converter.ConversionOptions(recursive=True), (tc, ), {}) self.assertEqual(1, self.evaluate(x))
def test_converted_call_then_already_converted_dynamic(self): @api.convert() def g(x): if x > 0: return x else: return -x def f(g, x): return g(x) x = api.converted_call(f, (g, constant_op.constant(1)), None, options=DEFAULT_RECURSIVE) self.assertEqual(self.evaluate(x), 1)
def test_converted_call_callable_abc(self): test_self = self @six.add_metaclass(abc.ABCMeta) class TestBase(object): @abc.abstractmethod def __call__(self): test_self.fail('This should not be called') class TestSubclass(TestBase): def __init__(self): test_self.assertFalse( converter_testing.is_inside_generated_code()) def __call__(self, expected): test_self.assertTrue(expected) test_self.assertTrue( converter_testing.is_inside_generated_code()) tc = api.converted_call(TestSubclass, (), None, options=DEFAULT_RECURSIVE) api.converted_call(tc, (True, ), None, options=DEFAULT_RECURSIVE)
def test_converted_call_avoids_triggering_operators(self): test_self = self class Pair(collections.namedtuple('Pair', ['a', 'b'])): def __call__(self): return self.a + self.b def __eq__(self, other): test_self.fail('Triggered operator') p = Pair(constant_op.constant(1), constant_op.constant(2)) x = api.converted_call(p, (), {}, options=DEFAULT_RECURSIVE) self.assertIsNotNone(self.evaluate(x), 3)
def test_converted_call_method_by_class(self): class TestClass(object): def __init__(self, x): self.x = x def test_method(self): if self.x < 0: return -self.x return self.x with self.cached_session() as sess: tc = TestClass(constant_op.constant(-1)) x = api.converted_call(TestClass.test_method, None, converter.ConversionOptions(), tc) self.assertEqual(1, self.evaluate(x))
def test_converted_call_synthetic_method(self): class TestClass(object): def __init__(self, x): self.x = x def test_function(self): if self.x < 0: return -self.x return self.x tc = TestClass(constant_op.constant(-1)) test_method = types.MethodType(test_function, tc) x = api.converted_call(test_method, None, converter.ConversionOptions(), (), {}) self.assertEqual(1, self.evaluate(x))
def test_converted_call_method_by_class(self): class TestClass(object): def __init__(self, x): self.x = x def test_method(self): if self.x < 0: return -self.x return self.x with self.test_session() as sess: tc = TestClass(constant_op.constant(-1)) x = api.converted_call(TestClass.test_method, False, False, False, {}, tc) self.assertEqual(1, sess.run(x))
def test_converted_call_namedtuple_subclass_unbound_method(self): class TestClass(collections.namedtuple('TestNamedtuple', ('a', 'b'))): def test_method(self, x): while tf.reduce_sum(x) > self.a: x //= self.b return x opts = converter.ConversionOptions(recursive=True) obj = TestClass(5, 2) x = api.converted_call(TestClass.test_method, opts, (obj, constant_op.constant([2, 4])), {}) self.assertAllEqual(self.evaluate(x), [1, 2])
def test_converted_call_callable_object(self): class TestClass(object): def __init__(self, x): self.x = x def __call__(self): if self.x < 0: return -self.x return self.x with self.cached_session() as sess: tc = TestClass(constant_op.constant(-1)) x = api.converted_call(tc, None, converter.ConversionOptions()) self.assertEqual(1, sess.run(x))
def test_converted_call_method(self): class TestClass(object): def __init__(self, x): self.x = x def test_method(self): if self.x < 0: return -self.x return self.x with self.cached_session() as sess: tc = TestClass(constant_op.constant(-1)) x = api.converted_call(tc.test_method, api.ConversionOptions.new(), tc) self.assertEqual(1, sess.run(x))
def test_converted_call_namedtuple_subclass_unbound_method(self): class TestClass(collections.namedtuple('TestNamedtuple', ('a', 'b'))): def test_method(self, x): while tf.reduce_sum(x) > self.a: x //= self.b return x obj = TestClass(5, 2) x = api.converted_call( TestClass.test_method, (obj, constant_op.constant([2, 4])), None, options=DEFAULT_RECURSIVE) self.assertAllEqual(self.evaluate(x), [1, 2])
def test_converted_call_constructor(self): class TestClass(object): def __init__(self, x): self.x = x def test_method(self): if self.x < 0: return -self.x return self.x with self.test_session() as sess: tc = api.converted_call(TestClass, False, False, False, {}, constant_op.constant(-1)) # tc is now a converted object. x = tc.test_method() self.assertEqual(1, sess.run(x))
def test_converted_call_method_converts_recursively(self): class TestClass(object): def __init__(self, x): self.x = x def other_method(self): if self.x < 0: return -self.x return self.x def test_method(self): return self.other_method() tc = TestClass(constant_op.constant(-1)) x = api.converted_call(tc.test_method, None, converter.ConversionOptions(recursive=True), tc) self.assertEqual(1, self.evaluate(x))
def test_converted_call_constructor(self): class TestClass(object): def __init__(self, x): self.x = x def test_method(self): if self.x < 0: return -self.x return self.x with self.cached_session() as sess: tc = api.converted_call(TestClass, None, converter.ConversionOptions(), constant_op.constant(-1)) # tc is now a converted object. x = tc.test_method() self.assertEqual(1, self.evaluate(x))
def test_converted_call_method_by_class(self): class TestClass(object): def __init__(self, x): self.x = x def test_method(self): if self.x < 0: return -self.x return self.x tc = TestClass(constant_op.constant(-1)) x = api.converted_call(TestClass.test_method, None, converter.ConversionOptions(recursive=True), (tc,), {}) self.assertEqual(1, self.evaluate(x))
def test_converted_call_method_by_class(self): class TestClass(object): def __init__(self, x): self.x = x def test_method(self): if self.x < 0: return -self.x return self.x with self.cached_session() as sess: tc = TestClass(constant_op.constant(-1)) x = api.converted_call(TestClass.test_method, None, converter.ConversionOptions(), tc) self.assertEqual(1, self.evaluate(x))
def test_converted_call_defun_object_method(self): # pylint:disable=method-hidden class TestClass(object): def method(self): return 1 def prepare(self): self.method = function.defun(self.method) # pylint:enable=method-hidden tc = TestClass() tc.prepare() x = api.converted_call(tc.method, (), None, options=DEFAULT_RECURSIVE) self.assertAllEqual(1, self.evaluate(x))
def test_converted_call_callable_metaclass(self): class TestMetaclass(type): x = constant_op.constant(-1) def __call__(cls): if cls.x < 0: cls.x = -cls.x return cls tc = TestMetaclass('TestClass', (), {}) # This functools.partial will hide the class form the constructor # check. Not ideal. See b/120224672. tc = functools.partial(tc) converted_tc = api.converted_call(tc, (), None, options=DEFAULT_RECURSIVE) self.assertIsInstance(converted_tc, TestMetaclass) self.assertEqual(1, self.evaluate(converted_tc.x))
def test_converted_call_method_converts_recursively(self): class TestClass(object): def __init__(self, x): self.x = x def other_method(self): if self.x < 0: return -self.x return self.x def test_method(self): return self.other_method() tc = TestClass(constant_op.constant(-1)) x = api.converted_call(tc.test_method, (), None, options=DEFAULT_RECURSIVE) self.assertEqual(1, self.evaluate(x))
def test_converted_call_constructor(self): class TestClass(object): def __init__(self, x): self.x = x def test_method(self): if self.x < 0: return -self.x return self.x tc = api.converted_call(TestClass, (constant_op.constant(-1), ), None, options=DEFAULT_RECURSIVE) # tc is still a TestClass - constructors are whitelisted. # TODO(b/124016764): Support this use case. # The error below is specific to the `if` statement not being converted. with self.assertRaises(TypeError): tc.test_method()
def test_converted_call_constructor(self): class TestClass(object): def __init__(self, x): self.x = x def test_method(self): if self.x < 0: return -self.x return self.x tc = api.converted_call(TestClass, None, converter.ConversionOptions(), (constant_op.constant(-1), ), {}) # tc is still a TestClass - constructors are whitelisted. # TODO(b/124016764): Support this use case. # The error below is specific to the `if` statement not being converted. with self.assertRaisesRegex(TypeError, 'Using a `tf.Tensor` as a Python `bool`'): tc.test_method()
def test_super_with_two_args(self): test_case_self = self class TestBase(object): def plus_three(self, x): return x + 3 class TestSubclass(TestBase): def plus_three(self, x): test_case_self.fail('This should never be called.') def two_args(self, x): return super(TestSubclass, self).plus_three(x) tc = api.converted_call(TestSubclass, (), None, options=DEFAULT_RECURSIVE) self.assertEqual(5, tc.two_args(2))
def test_super_with_two_args(self): test_case_self = self class TestBase(object): def plus_three(self, x): return x + 3 class TestSubclass(TestBase): def plus_three(self, x): test_case_self.fail('This should never be called.') def two_args(self, x): return super(TestSubclass, self).plus_three(x) tc = api.converted_call(TestSubclass, converter.ConversionOptions(recursive=True), (), {}) self.assertEqual(5, tc.two_args(2))
def test_converted_call_method_as_object_attribute(self): class AnotherClass(object): def __init__(self): self.another_class_attr = constant_op.constant(1) def method(self): if self.another_class_attr > 0: return self.another_class_attr + 1 return self.another_class_attr + 10 class TestClass(object): def __init__(self, another_obj_method): self.another_obj_method = another_obj_method obj = AnotherClass() tc = TestClass(obj.method) x = api.converted_call('another_obj_method', tc, converter.ConversionOptions(), (), {}) self.assertEqual(self.evaluate(x), 2)
def test_converted_call_defun_object_method(self): opts = converter.ConversionOptions(recursive=True) # pylint:disable=method-hidden class TestClass(object): def method(self): return 1 def prepare(self): self.method = function.defun(self.method) # pylint:enable=method-hidden tc = TestClass() tc.prepare() x = api.converted_call(tc.method, None, opts, (), {}) self.assertAllEqual(1, self.evaluate(x))
def test_super_with_one_arg(self): test_case_self = self class TestBase(object): def plus_three(self, x): return x + 3 class TestSubclass(TestBase): def plus_three(self, x): test_case_self.fail('This should never be called.') def one_arg(self, x): test_base_unbound = super(TestSubclass) test_base = test_base_unbound.__get__(self, TestSubclass) return test_base.plus_three(x) tc = api.converted_call(TestSubclass, converter.ConversionOptions(recursive=True), (), {}) self.assertEqual(5, tc.one_arg(2))
def test_converted_call_callable_metaclass(self): test_self = self class TestMetaclass(type): def __call__(cls): self.assertTrue(converter_testing.is_inside_generated_code()) inst = object.__new__(cls) inst.__init__() def instance_call(unused_self): test_self.fail( 'The class-bound __call__ should be called, not the instance' ' bound one.') inst.__call__ = instance_call return inst tmc = TestMetaclass('TestClass', (), {}) tc = api.converted_call(tmc, (), None, options=DEFAULT_RECURSIVE) self.assertIsInstance(tc, tmc)
def test_super_with_one_arg(self): test_case_self = self class TestBase(object): def plus_three(self, x): return x + 3 class TestSubclass(TestBase): def plus_three(self, x): test_case_self.fail('This should never be called.') def one_arg(self, x): test_base_unbound = super(TestSubclass) test_base = test_base_unbound.__get__(self, TestSubclass) return test_base.plus_three(x) tc = api.converted_call(TestSubclass, (), None, options=DEFAULT_RECURSIVE) self.assertEqual(5, tc.one_arg(2))