def test_no_recycling(): if theano.config.cxx == '': raise SkipTest('need c++') x = theano.tensor.vector() for lnk in [ vm.VM_Linker(use_cloop=True), vm.VM_Linker(use_cloop=False, lazy=True), vm.VM_Linker(use_cloop=False, lazy=False, allow_gc=True), vm.VM_Linker(use_cloop=False, lazy=False, allow_gc=False) ]: mode = theano.Mode(optimizer='fast_compile', linker=lnk) f = theano.function([x], x + 1, mode=mode) f2 = theano.function([x], (x + 1) * 2, mode=mode) m1 = f.fn.thunks[0].thunk.module m2 = f2.fn.thunks[0].thunk.module assert m1 is m2
def test_speed_lazy(): def build_graph(x, depth=5): z = x for d in range(depth): z = ifelse(z[0] > 0, -z, z) return z def time_linker(name, linker): steps_a = 10 steps_b = 100 x = tensor.vector() a = build_graph(x, steps_a) b = build_graph(x, steps_b) f_a = function([x], a, mode=Mode(optimizer=None, linker=linker())) f_b = function([x], b, mode=Mode(optimizer=None, linker=linker())) f_a([2.0]) t0 = time.time() f_a([2.0]) t1 = time.time() f_b([2.0]) t2 = time.time() f_b([2.0]) t3 = time.time() t_a = t1 - t0 t_b = t3 - t2 print("%s takes %f s/Kop" % ( name, (1000 * (t_b - t_a) / (steps_b - steps_a)))) time_linker('vmLinker', vm.VM_Linker) time_linker('vmLinker_nogc', lambda: vm.VM_Linker(allow_gc=False)) if theano.config.cxx: time_linker('vmLinker_C', lambda: vm.VM_Linker(allow_gc=False, use_cloop=True))
def test_callback_with_ifelse(self): a, b, c = tensor.scalars('abc') f = function([a, b, c], ifelse(a, 2 * b, 2 * c), mode=Mode(optimizer=None, linker=vm.VM_Linker(callback=self.callback))) f(1, 2, 3) assert self.n_callbacks['IfElse'] == 2
def test_callback(self): a, b, c = tensor.scalars('abc') f = function([a, b, c], (a + b) + c, mode=Mode(optimizer=None, linker=vm.VM_Linker(callback=self.callback))) f(1, 2, 3) assert sum(self.n_callbacks.values()) == len(f.maker.fgraph.toposort()) f(1, 2, 3) assert (sum( self.n_callbacks.values()) == len(f.maker.fgraph.toposort()) * 2)
def test_partial_function(): import numpy as np from theano.tests import unittest_tools as utt x = tensor.scalar('input') y = x ** 2 f = theano.function([x], [y + 7, y - 9, y / 14.], mode=Mode( optimizer=None, linker=vm.VM_Linker(allow_partial_eval=True))) assert f(3, output_subset=[0, 1, 2]) == f(3) assert f(4, output_subset=[0, 2]) == [f(4)[0], f(4)[2]] utt.assert_allclose(f(5), np.array([32., 16., 1.7857142857142858]))
def test_partial_function_with_output_keys(): def check_partial_function_output_keys(linker_name): x = tensor.scalar("input") y = 3 * x f = theano.function( [x], {"a": y * 5, "b": y - 7}, mode=Mode(optimizer=None, linker=linker_name) ) assert f(5, output_subset=["a"])["a"] == f(5)["a"] check_partial_function_output_keys( vm.VM_Linker(allow_partial_eval=True, use_cloop=False) ) check_partial_function_output_keys("cvm")
def test_partial_function_with_output_keys(): def check_partial_function_output_keys(linker_name): x = tensor.scalar('input') y = 3 * x f = theano.function([x], {'a': y * 5, 'b': y - 7}, mode=Mode( optimizer=None, linker=linker_name)) assert f(5, output_subset=['a'])['a'] == f(5)['a'] check_partial_function_output_keys(vm.VM_Linker(allow_partial_eval=True, use_cloop=False)) if not theano.config.cxx: raise SkipTest("Need cxx for this test") check_partial_function_output_keys('cvm')
def test_no_leak_many_call_lazy(): # Verify no memory leaks when calling a function a lot of times # This isn't really a unit test, you have to run it and look at top to # see if there's a leak def build_graph(x, depth=5): z = x for d in range(depth): z = ifelse(z.mean() > 0.5, -z, z) return z def time_linker(name, linker): steps_a = 10 x = tensor.dvector() a = build_graph(x, steps_a) f_a = function([x], a, mode=Mode(optimizer=None, linker=linker())) inp = np.random.rand(1000000) for i in range(100): f_a(inp) # this doesn't seem to work, prints 0 for everything # import resource # # pre = resource.getrusage(resource.RUSAGE_SELF) # post = resource.getrusage(resource.RUSAGE_SELF) # print(pre.ru_ixrss, post.ru_ixrss) # print(pre.ru_idrss, post.ru_idrss) # print(pre.ru_maxrss, post.ru_maxrss) print(1) time_linker("vmLinker_C", lambda: vm.VM_Linker(allow_gc=False, use_cloop=True)) print(2) time_linker("vmLinker", lambda: vm.VM_Linker(allow_gc=False, use_cloop=False))
def test_c_thunks(): a = tensor.scalars('a') b, c = tensor.vectors('bc') cases = [False] if theano.config.cxx: cases.append(True) for c_thunks in cases: f = function([a, b, c], ifelse(a, a * b, b * c), mode=Mode(optimizer=None, linker=vm.VM_Linker(c_thunks=c_thunks, use_cloop=False))) f(1, [2], [3, 2]) from nose.tools import assert_raises assert_raises(ValueError, f, 0, [2], [3, 4]) assert any([hasattr(t, 'cthunk') for t in f.fn.thunks]) == c_thunks
def test_c_thunks(): a = tensor.scalars("a") b, c = tensor.vectors("bc") cases = [False] if theano.config.cxx: cases.append(True) for c_thunks in cases: f = function( [a, b, c], ifelse(a, a * b, b * c), mode=Mode(optimizer=None, linker=vm.VM_Linker(c_thunks=c_thunks, use_cloop=False)), ) f(1, [2], [3, 2]) with pytest.raises(ValueError): f(0, [2], [3, 4]) assert any([hasattr(t, "cthunk") for t in f.fn.thunks]) == c_thunks
def test_partial_function(): from theano.tests import unittest_tools as utt def check_partial_function(linker_name): x = tensor.scalar('input') y = x ** 2 f = theano.function([x], [y + 7, y - 9, y / 14.], mode=Mode( optimizer=None, linker=linker_name)) assert f(3, output_subset=[0, 1, 2]) == f(3) assert f(4, output_subset=[0, 2]) == [f(4)[0], f(4)[2]] utt.assert_allclose(f(5), np.array([32., 16., 1.7857142857142858])) check_partial_function(vm.VM_Linker(allow_partial_eval=True, use_cloop=False)) if not theano.config.cxx: raise SkipTest("Need cxx for this test") check_partial_function('cvm')
def test_partial_function_with_updates(): def check_updates(linker_name): x = tensor.lscalar('input') y = theano.shared(numpy.asarray(1, 'int64'), name='global') f = theano.function([x], [x, x + 34], updates=[(y, x + 1)], mode=Mode(optimizer=None, linker=linker_name)) g = theano.function([x], [x - 6], updates=[(y, y + 3)], mode=Mode(optimizer=None, linker=linker_name)) assert f(3, output_subset=[]) == [] assert y.get_value() == 4 assert g(30, output_subset=[0]) == [24] assert g(40, output_subset=[]) == [] assert y.get_value() == 10 check_updates(vm.VM_Linker(allow_partial_eval=True, use_cloop=False)) check_updates('cvm')
def test_no_leak_many_call_nonlazy(): # Verify no memory leaks when calling a function a lot of times # This isn't really a unit test, you have to run it and look at top to see # if there's a leak def build_graph(x, depth=5): z = x for d in range(depth): z = tensor.sin(-z + 1) return z def time_linker(name, linker): steps_a = 10 x = tensor.vector() a = build_graph(x, steps_a) f_a = function([x], a, mode=Mode(optimizer=None, linker=linker())) for i in xrange(500000): f_a([2.0]) time_linker('vmLinker_C', lambda: vm.VM_Linker(allow_gc=False, use_cloop=True))
def test_speed(): def build_graph(x, depth=5): z = x for d in range(depth): z = z + z return z def numpy_version(x, depth): z = x for d in range(depth): z = z + z return z def time_numpy(): steps_a = 5 steps_b = 100 x = np.asarray([2.0, 3.0], dtype=theano.config.floatX) numpy_version(x, steps_a) t0 = time.time() # print numpy_version(x, steps_a) t1 = time.time() t2 = time.time() # print numpy_version(x, steps_b) t3 = time.time() t_a = t1 - t0 t_b = t3 - t2 print("%s takes %f s/Kop" % ("numpy", (1000 * (t_b - t_a) / (steps_b - steps_a)))) def time_linker(name, linker): steps_a = 5 steps_b = 100 x = tensor.vector() a = build_graph(x, steps_a) b = build_graph(x, steps_b) f_a = function([x], a, mode=Mode(optimizer=None, linker=linker())) f_b = function([x], b, mode=Mode(optimizer=None, linker=linker())) f_a([2.0, 3.0]) t0 = time.time() f_a([2.0, 3.0]) t1 = time.time() f_b([2.0, 3.0]) t2 = time.time() f_b([2.0, 3.0]) t3 = time.time() t_a = t1 - t0 t_b = t3 - t2 print("%s takes %f s/Kop" % (name, (1000 * (t_b - t_a) / (steps_b - steps_a)))) time_linker("c|py", OpWiseCLinker) time_linker("vmLinker", vm.VM_Linker) time_linker("vmLinker_nogc", lambda: vm.VM_Linker(allow_gc=False)) if theano.config.cxx: time_linker("vmLinker_CLOOP", lambda: vm.VM_Linker(allow_gc=False, use_cloop=True)) time_numpy()
def test_speed(): if not theano.config.cxx: raise SkipTest("G++ not available, so we need to skip this test.") def build_graph(x, depth=5): z = x for d in range(depth): z = (z + z) return z def numpy_version(x, depth): z = x for d in xrange(depth): z = (z + z) return z def time_numpy(): steps_a = 5 steps_b = 100 x = numpy.asarray([2.0, 3.0], dtype=theano.config.floatX) numpy_version(x, steps_a) t0 = time.time() # print numpy_version(x, steps_a) t1 = time.time() t2 = time.time() # print numpy_version(x, steps_b) t3 = time.time() t_a = t1 - t0 t_b = t3 - t2 print "%s takes %f s/Kop" % ('numpy', (1000 * (t_b - t_a) / (steps_b - steps_a))) def time_linker(name, linker): steps_a = 5 steps_b = 100 x = tensor.vector() a = build_graph(x, steps_a) b = build_graph(x, steps_b) f_a = function([x], a, mode=Mode(optimizer=None, linker=linker())) f_b = function([x], b, mode=Mode(optimizer=None, linker=linker())) f_a([2.0, 3.0]) t0 = time.time() f_a([2.0, 3.0]) t1 = time.time() f_b([2.0, 3.0]) t2 = time.time() f_b([2.0, 3.0]) t3 = time.time() t_a = t1 - t0 t_b = t3 - t2 print "%s takes %f s/Kop" % (name, (1000 * (t_b - t_a) / (steps_b - steps_a))) time_linker('c|py', OpWiseCLinker) time_linker('vmLinker', vm.VM_Linker) time_linker('vmLinker_nogc', lambda: vm.VM_Linker(allow_gc=False)) if theano.config.cxx: time_linker('vmLinker_CLOOP', lambda: vm.VM_Linker(allow_gc=False, use_cloop=True)) time_numpy()