def f(klass): assert issubclass(klass, unittest.TestCase) def setUp(self): self.x, self.gy = make_data(self.shape, self.dtype) if self.dtype == numpy.float16: self.backward_options = { 'eps': 2 ** -4, 'atol': 2 ** -4, 'rtol': 2 ** -4, 'dtype': numpy.float64} else: self.backward_options = {'atol': 1e-4, 'rtol': 1e-4} setattr(klass, "setUp", setUp) def check_forward(self, x_data): x = chainer.Variable(x_data) y = func(x) self.assertEqual(y.data.dtype, x_data.dtype) y_expected = func_expected(cuda.to_cpu(x_data), dtype=x_data.dtype) testing.assert_allclose(y_expected, y.data, atol=1e-4, rtol=1e-4) setattr(klass, "check_forward", check_forward) @condition.retry(3) def test_forward_cpu(self): self.check_forward(self.x) setattr(klass, "test_forward_cpu", test_forward_cpu) @attr.gpu @condition.retry(3) def test_forward_gpu(self): self.check_forward(cuda.to_gpu(self.x)) setattr(klass, "test_forward_gpu", test_forward_gpu) def check_backward(self, x_data, y_grad): gradient_check.check_backward( func, x_data, y_grad, **self.backward_options) setattr(klass, "check_backward", check_backward) @condition.retry(3) def test_backward_cpu(self): self.check_backward(self.x, self.gy) setattr(klass, "test_backward_cpu", test_backward_cpu) @attr.gpu @condition.retry(3) def test_backward_gpu(self): self.check_backward(cuda.to_gpu(self.x), cuda.to_gpu(self.gy)) setattr(klass, "test_backward_gpu", test_backward_gpu) def test_label(self): self.assertEqual(func.label, label_expected) setattr(klass, "test_label", test_label) # Return parameterized class. return testing.parameterize(*testing.product({ 'shape': [(3, 2), ()], 'dtype': [numpy.float16, numpy.float32, numpy.float64] }))(klass)
def f(klass): assert issubclass(klass, unittest.TestCase) def setUp(self): self.x, self.gy = make_data(self.shape, self.dtype) if self.dtype == numpy.float16: self.backward_options = { 'eps': 2 ** -4, 'atol': 2 ** -4, 'rtol': 2 ** -4, 'dtype': numpy.float64} else: self.backward_options = {'atol': 1e-4, 'rtol': 1e-4} setattr(klass, "setUp", setUp) def check_forward(self, x_data): x = variable.Variable(x_data) y = func(x) self.assertEqual(y.data.dtype, x_data.dtype) y_expected = func_expected(cuda.to_cpu(x_data), dtype=x_data.dtype) testing.assert_allclose(y_expected, y.data, atol=1e-4, rtol=1e-4) setattr(klass, "check_forward", check_forward) @condition.retry(3) def test_forward_cpu(self): self.check_forward(self.x) setattr(klass, "test_forward_cpu", test_forward_cpu) @attr.gpu @condition.retry(3) def test_forward_gpu(self): self.check_forward(cuda.to_gpu(self.x)) setattr(klass, "test_forward_gpu", test_forward_gpu) def check_backward(self, x_data, y_grad): gradient_check.check_backward( func, x_data, y_grad, **self.backward_options) setattr(klass, "check_backward", check_backward) @condition.retry(3) def test_backward_cpu(self): self.check_backward(self.x, self.gy) setattr(klass, "test_backward_cpu", test_backward_cpu) @attr.gpu @condition.retry(3) def test_backward_gpu(self): self.check_backward(cuda.to_gpu(self.x), cuda.to_gpu(self.gy)) setattr(klass, "test_backward_gpu", test_backward_gpu) def test_label(self): self.assertEqual(func.label, label_expected) setattr(klass, "test_label", test_label) # Return parameterized class. return testing.parameterize(*testing.product({ 'shape': [(3, 2), ()], 'dtype': [numpy.float16, numpy.float32, numpy.float64] }))(klass)
def parameterize_batch_renormalization(): return testing.parameterize(*(testing.product({ 'ndim': [0, 1, 2], 'eps': [2e-5, 1e-1], 'dtype': [numpy.float32], 'update_statistics': [True, False], }) + testing.product({ 'ndim': [1], 'eps': [2e-5, 1e-1], 'dtype': [numpy.float16, numpy.float32, numpy.float64], 'update_statistics': [True, False], })))
def parameterize_batch_renormalization(): return testing.parameterize(*(testing.product({ 'ndim': [0, 1, 2], 'eps': [2e-5, 1e-1], 'dtype': [numpy.float32], 'update_statistics': [True, False], }) + testing.product({ 'ndim': [1], 'eps': [2e-5, 1e-1], 'dtype': [numpy.float16, numpy.float32, numpy.float64], 'update_statistics': [True, False], })))
def deco(cls): setUp_orig = cls.setUp def setUp(self): param = params[self._chainercv_parameterize_index] print('params: {}'.format(param)) for k, v in six.iteritems(param): setattr(self, k, v) setUp_orig(self) cls.setUp = setUp params_indices = [{ '_chainercv_parameterize_index': i } for i in range(len(params))] return testing.parameterize(*params_indices)(cls)
def f(klass): assert issubclass(klass, unittest.TestCase) def setUp(self): if is_new_style: self.x, self.gy, self.ggx = make_data(self.shape, self.dtype) else: self.x, self.gy = make_data(self.shape, self.dtype) self.forward_options = {'atol': 1e-4, 'rtol': 1e-4} if self.dtype == numpy.float16: self.backward_options = { 'eps': 2 ** -4, 'atol': 2 ** -4, 'rtol': 2 ** -4, 'dtype': numpy.float64} self.double_backward_options = { 'eps': 2 ** -4, 'atol': 2 ** -4, 'rtol': 2 ** -4, 'dtype': numpy.float64} else: self.backward_options = { 'dtype': numpy.float64, 'atol': 1e-4, 'rtol': 1e-4} self.double_backward_options = { 'dtype': numpy.float64, 'atol': 1e-4, 'rtol': 1e-4} if forward_options is not None: self.forward_options.update(forward_options) if backward_options is not None: self.backward_options.update(backward_options) if double_backward_options is not None: self.double_backward_options.update(double_backward_options) setattr(klass, "setUp", setUp) def check_forward(self, x_data): x = variable.Variable(x_data) y = func(x) self.assertEqual(y.data.dtype, x_data.dtype) y_expected = func_expected(cuda.to_cpu(x_data), dtype=x_data.dtype) testing.assert_allclose(y_expected, y.data, **self.forward_options) setattr(klass, "check_forward", check_forward) def test_forward_cpu(self): self.check_forward(self.x) setattr(klass, "test_forward_cpu", test_forward_cpu) @attr.gpu def test_forward_gpu(self): self.check_forward(cuda.to_gpu(self.x)) setattr(klass, "test_forward_gpu", test_forward_gpu) def check_backward(self, x_data, y_grad): gradient_check.check_backward( func, x_data, y_grad, **self.backward_options) setattr(klass, "check_backward", check_backward) def test_backward_cpu(self): self.check_backward(self.x, self.gy) setattr(klass, "test_backward_cpu", test_backward_cpu) @attr.gpu def test_backward_gpu(self): self.check_backward(cuda.to_gpu(self.x), cuda.to_gpu(self.gy)) setattr(klass, "test_backward_gpu", test_backward_gpu) if is_new_style: def check_double_backward(self, x_data, y_grad, x_grad_grad): func1 = _nonlinear(func) if is_linear else func gradient_check.check_double_backward( func1, x_data, y_grad, x_grad_grad, **self.double_backward_options) setattr(klass, "check_double_backward", check_double_backward) def test_double_backward_cpu(self): self.check_double_backward(self.x, self.gy, self.ggx) setattr(klass, "test_double_backward_cpu", test_double_backward_cpu) @attr.gpu def test_double_backward_gpu(self): self.check_double_backward( cuda.to_gpu(self.x), cuda.to_gpu(self.gy), cuda.to_gpu(self.ggx)) setattr(klass, "test_double_backward_gpu", test_double_backward_gpu) if func_class is not None: def test_label(self): self.assertEqual(func_class().label, label_expected) setattr(klass, "test_label", test_label) # Return parameterized class. return testing.parameterize(*testing.product({ 'shape': [(3, 2), ()], 'dtype': [numpy.float16, numpy.float32, numpy.float64] }))(klass)
def f(klass): assert issubclass(klass, unittest.TestCase) def setUp(self): if is_new_style: self.x, self.gy, self.ggx = make_data(self.shape, self.dtype) else: self.x, self.gy = make_data(self.shape, self.dtype) if self.dtype == numpy.float16: self.backward_options = { 'eps': 2**-4, 'atol': 2**-4, 'rtol': 2**-4, 'dtype': numpy.float64 } self.double_backward_options = { 'eps': 2**-4, 'atol': 2**-4, 'rtol': 2**-4, 'dtype': numpy.float64 } else: self.backward_options = { 'dtype': numpy.float64, 'atol': 1e-4, 'rtol': 1e-4 } self.double_backward_options = { 'dtype': numpy.float64, 'atol': 1e-4, 'rtol': 1e-4 } if backward_options is not None: self.backward_options.update(backward_options) if double_backward_options is not None: self.double_backward_options.update(double_backward_options) setattr(klass, "setUp", setUp) def check_forward(self, x_data): x = variable.Variable(x_data) y = func(x) self.assertEqual(y.data.dtype, x_data.dtype) y_expected = func_expected(cuda.to_cpu(x_data), dtype=x_data.dtype) testing.assert_allclose(y_expected, y.data, atol=1e-4, rtol=1e-4) setattr(klass, "check_forward", check_forward) def test_forward_cpu(self): self.check_forward(self.x) setattr(klass, "test_forward_cpu", test_forward_cpu) @attr.gpu def test_forward_gpu(self): self.check_forward(cuda.to_gpu(self.x)) setattr(klass, "test_forward_gpu", test_forward_gpu) def check_backward(self, x_data, y_grad): gradient_check.check_backward(func, x_data, y_grad, **self.backward_options) setattr(klass, "check_backward", check_backward) def test_backward_cpu(self): self.check_backward(self.x, self.gy) setattr(klass, "test_backward_cpu", test_backward_cpu) @attr.gpu def test_backward_gpu(self): self.check_backward(cuda.to_gpu(self.x), cuda.to_gpu(self.gy)) setattr(klass, "test_backward_gpu", test_backward_gpu) if is_new_style: def check_double_backward(self, x_data, y_grad, x_grad_grad): func1 = _nonlinear(func) if is_linear else func gradient_check.check_double_backward( func1, x_data, y_grad, x_grad_grad, **self.double_backward_options) setattr(klass, "check_double_backward", check_double_backward) def test_double_backward_cpu(self): self.check_double_backward(self.x, self.gy, self.ggx) setattr(klass, "test_double_backward_cpu", test_double_backward_cpu) @attr.gpu def test_double_backward_gpu(self): self.check_double_backward(cuda.to_gpu(self.x), cuda.to_gpu(self.gy), cuda.to_gpu(self.ggx)) setattr(klass, "test_double_backward_gpu", test_double_backward_gpu) if func_class is not None: def test_label(self): self.assertEqual(func_class().label, label_expected) setattr(klass, "test_label", test_label) # Return parameterized class. return testing.parameterize(*testing.product({ 'shape': [(3, 2), ()], 'dtype': [numpy.float16, numpy.float32, numpy.float64] }))(klass)
import six import numpy as np import chainer from chainer import optimizers from chainer import testing _parameterize_optimizers = testing.parameterize(*testing.product({ 'optimizer_impl': [ optimizers.AdaDelta, optimizers.AdaGrad, optimizers.Adam, optimizers.CorrectedMomentumSGD, optimizers.MomentumSGD, optimizers.MSVAG, optimizers.NesterovAG, optimizers.RMSprop, optimizers.RMSpropGraves, optimizers.SGD, optimizers.SMORMS3, ] })) @_parameterize_optimizers class TestOptimizerHyperparameter(unittest.TestCase): def setUp(self): self.target = chainer.Link() with self.target.init_scope(): self.target.w = chainer.Parameter()
'AdamW', 'AMSGrad', 'AdaBound', 'AMSBound', 'CorrectedMomentumSGD', 'MomentumSGD', 'MSVAG', 'NesterovAG', 'RMSprop', 'RMSpropGraves', 'SGD', 'SMORMS3', ] _parameterize_optimizers = testing.parameterize(*testing.product({ 'optimizer_impl': [getattr(chainer.optimizers, o) for o in _all_optimizers] })) class SimpleChain(chainer.Chain): def __init__(self, shape=()): super(SimpleChain, self).__init__() w_np = np.asarray(np.random.randn(*shape)).astype(np.float32) with self.init_scope(): self.w = chainer.Parameter(w_np, name='w') def __call__(self, x): return F.sum((x - self.w)**2) class TestAllOptimizersCoverage(unittest.TestCase):
from chainer.testing import condition from chainer.utils import type_check import chainerx _parameterize = testing.parameterize(*(testing.product_dict( testing.product({ 'test': [True, False], 'size': ['skip', 'explicit'], 'dtype': [numpy.float16, numpy.float32, numpy.float64, chainer.mixed16], }), testing.product({ 'ndim': [0, 1, 2, 3], }) + [ { 'input_shape': (5, 4, 3, 2), 'axis': (0, 2, 3) }, { 'input_shape': (5, 4), 'axis': 0 }, { 'input_shape': (5, 4, 3), 'axis': (0, 1) }, ]))) _inject_backend_tests = testing.inject_backend_tests( None, # CPU tests
from chainer import links from chainer import testing from chainer.testing import attr from chainer.testing import condition from chainer.utils import type_check import chainerx _parameterize = testing.parameterize(*(testing.product_dict( testing.product({ 'test': [True, False], 'size': ['skip', 'explicit'], 'dtype': [numpy.float16, numpy.float32, numpy.float64, chainer.mixed16], }), testing.product({ 'ndim': [0, 1, 2, 3], }) + [ {'input_shape': (5, 4, 3, 2), 'axis': (0, 2, 3)}, {'input_shape': (5, 4), 'axis': 0}, {'input_shape': (5, 4, 3), 'axis': (0, 1)}, ] ))) _inject_backend_tests = testing.inject_backend_tests( None, # CPU tests [ {}, {'use_ideep': 'always'},