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 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 inject_backend_tests(method_names):
decorator = backend.inject_backend_tests(
method_names,
# CPU tests
testing.product({
'use_cuda': [False],
'use_ideep': ['never', 'always'],
})
# GPU tests
+ [{'use_cuda': True}])
return decorator
def _create_paramters():
split_years = testing.product({
'split': ['train', 'trainval', 'val'],
'year': ['2007', '2012']})
split_years += [{'split': 'test', 'year': '2007'}]
params = testing.product_dict(
split_years,
[{'use_difficult': True, 'return_difficult': True},
{'use_difficult': True, 'return_difficult': False},
{'use_difficult': False, 'return_difficult': True},
{'use_difficult': False, 'return_difficult': False}])
return params
def inject_backend_tests(method_names):
decorator = backend.inject_backend_tests(
method_names,
# CPU tests
testing.product({
'use_cuda': [False],
'use_ideep': ['never', 'always'],
})
# GPU tests
+ [{'use_cuda': True}]
# ChainerX tests
+ [
{'use_chainerx': True, 'chainerx_device': 'native:0'},
{'use_chainerx': True, 'chainerx_device': 'cuda:0'},
])
return decorator
import unittest
from chainer import cuda
from chainer import testing
from chainer.testing import attr
from chainer.testing import condition
import numpy
from chainerrl.functions.mellowmax import maximum_entropy_mellowmax
from chainerrl.functions.mellowmax import mellowmax
@testing.parameterize(*testing.product({
'shape': [(1, 1), (2, 3), (2, 3, 4), (2, 3, 4, 5)],
'dtype': [numpy.float32],
'omega': [10, 5, 1, -1, -5, -10],
'axis': [0, 1, -1, -2],
'same_value': [True, False],
}))
class TestMellowmax(unittest.TestCase):
def setUp(self):
self.x = numpy.random.uniform(-1, 1, self.shape).astype(self.dtype)
if self.same_value:
self.x[:] = numpy.random.uniform(-1, 1, 1).astype(self.dtype)
def check_forward(self, x_data):
xp = cuda.get_array_module(x_data)
y = mellowmax(x_data, axis=self.axis, omega=self.omega)
self.assertEqual(y.array.dtype, self.dtype)
x_min = xp.min(x_data, axis=self.axis)
def test_rtol_gpu(self):
self.check_rtol(cuda.to_gpu(self.x), cuda.to_gpu(self.y))
class Ident(chainer.Function):
def forward(self, inputs):
return inputs
def backward(self, inputs, grads):
return grads
# numpy.float16 is not tested because of the low precision.
@testing.parameterize(*testing.product({
'dtype': [None, numpy.float32, numpy.float64],
}))
@backend.inject_backend_tests(None, [
{},
{'use_cuda': True},
{'use_chainerx': True, 'chainerx_device': 'native:0'},
{'use_chainerx': True, 'chainerx_device': 'cuda:0'},
])
class TestCheckBackward(unittest.TestCase):
def test_multiple_output(self, backend_config):
x1 = backend_config.get_array(numpy.array([1], dtype='f'))
x2 = backend_config.get_array(numpy.array([1], dtype='f'))
g1 = backend_config.get_array(numpy.array([1], dtype='f'))
g2 = backend_config.get_array(numpy.array([1], dtype='f'))
import unittest
import chainer
import numpy
from chainer.backends import cuda
from chainer import functions
from chainer import gradient_check
from chainer import testing
from chainer.testing import attr
from chainer.utils import type_check
@testing.parameterize(*testing.product({
'shape': [(3, 2), ()],
'dtype': [numpy.float16, numpy.float32, numpy.float64]
}))
class TestMinimum(unittest.TestCase):
def setUp(self):
shape = self.shape
self.gy = numpy.random.uniform(-1, 1, shape).astype(self.dtype)
self.ggx1 = numpy.random.uniform(-1, 1, shape).astype(self.dtype)
self.ggx2 = numpy.random.uniform(-1, 1, shape).astype(self.dtype)
self.check_forward_options = {}
self.check_backward_options = {'dtype': numpy.float64}
self.check_double_backward_options = {'dtype': numpy.float64}
if self.dtype == numpy.float16:
eps = 2 ** -3
self.check_forward_options = {'atol': 1e-4, 'rtol': 1e-3}
self.check_backward_options = {'atol': 1e-2, 'rtol': 1e-1}
self._print_variables('gxs ', gxs)
self._print_variables('ggxs (actual) ', ggxs)
self._print_variables('ggxs (expected)', expected)
raise
def test_double_grad_cpu(self):
self.check_double_grad()
@attr.gpu
def test_double_grad_gpu(self):
self.use_gpu()
self.check_double_grad()
@testing.parameterize(*testing.product({
'loss_scale': [None, 1, 10],
}))
class TestGradSimple(GradTestBase, unittest.TestCase):
x_names = 'x',
y_names = 'y',
def forward(self):
self.y = self.x * self.x
def expected_grad(self):
grad = 2 * self.x * self.gy
if self.loss_scale is not None:
grad *= self.loss_scale
return [grad]
import six
import chainer
from chainer import cuda
from chainer import functions
from chainer import gradient_check
from chainer import testing
from chainer.testing import attr
from chainer.testing import condition
from chainer.utils import conv
import pooling_nd_helper
@testing.parameterize(*testing.product({
'dims': [(4,), (4, 3), (4, 3, 2)],
'cover_all': [True, False],
'dtype': [numpy.float16, numpy.float32, numpy.float64],
}))
class TestMaxPoolingND(unittest.TestCase):
def setUp(self):
self.ndim = len(self.dims)
self.ksize = (3,) * self.ndim
self.stride = (2,) * self.ndim
self.pad = (1,) * self.ndim
# Avoid unstability of numerical gradient
x_shape = (2, 3) + self.dims
self.x = numpy.arange(
functools.reduce(mul, x_shape), dtype=self.dtype).reshape(x_shape)
self.x = 2 * self.x / self.x.size - 1
@testing.parameterize(*testing.product({
# repeats is any of (int, bool or tuple) and
# axis is any of (int or None).
'params': (
# Repeats 1-D array
testing.product({
'shape': [(2,)],
'repeats': [0, 1, 2, True, (0,), (1,), (2,), (True,)],
'axis': [None, 0],
}) +
# Repeats 2-D array (with axis=None)
testing.product({
'shape': [(3, 2)],
'repeats': [4, (4,), (4,) * 6, (True,) * 6],
'axis': [None],
}) +
# Repeats 2-D array (with axis=0)
testing.product({
'shape': [(3, 2)],
'repeats': [5, (5,), (5,) * 3],
'axis': [0],
}) +
# Repeats 2-D array (with axis=1)
testing.product({
'shape': [(3, 2)],
'repeats': [5, (5,), (5,) * 2],
'axis': [1],
}) +
# Repeats 3-D array (with axis=-2)
testing.product({
'shape': [(3, 2, 4)],
'repeats': [5, (5,), (5,) * 2],
'axis': [-2],
})
),
'dtype': [numpy.float16, numpy.float32, numpy.float64],
}))
from __future__ import division
from __future__ import absolute_import
from builtins import * # NOQA
from future import standard_library
standard_library.install_aliases()
import collections
import unittest
from chainer import testing
from chainerrl.misc.collections import RandomAccessQueue
@testing.parameterize(*(testing.product({
'maxlen': [1, 10, None],
'init_seq': [None, [], range(5)],
})))
class TestRandomAccessQueue(unittest.TestCase):
def setUp(self):
if self.init_seq:
self.y_queue = RandomAccessQueue(self.init_seq, maxlen=self.maxlen)
self.t_queue = collections.deque(self.init_seq, maxlen=self.maxlen)
else:
self.y_queue = RandomAccessQueue(maxlen=self.maxlen)
self.t_queue = collections.deque(maxlen=self.maxlen)
def test1(self):
self.check_all()
self.check_popleft()
self.do_append(10)
grid = numpy.repeat(grid[None], in_shape[0], axis=0).astype(numpy.float32)
return grid
def _rotate_BCHW(x):
rotated_xs = []
for i in range(x.shape[0]):
x_i = x[i].transpose(1, 2, 0)
x_i = numpy.rot90(x_i)
rotated_xs.append(x_i.transpose(2, 0, 1))
rotated_xs = numpy.concatenate([r_x[None] for r_x in rotated_xs], axis=0)
return rotated_xs
@testing.parameterize(*testing.product({
'use_cudnn': ['always', 'never'],
}))
class TestSpatialTransformerSampler(unittest.TestCase):
in_shape = (2, 2, 4, 4)
out_shape = (2, 2, 3, 3)
grid_shape = (2, 2, 3, 3)
def setUp(self):
self.x = numpy.random.uniform(
size=self.in_shape).astype(numpy.float32)
self.grid = numpy.random.uniform(
low=-2., high=2., size=self.grid_shape).astype(numpy.float32)
self.grads = numpy.random.uniform(
size=self.out_shape).astype(numpy.float32)
import numpy as np
import unittest
import chainer
from chainer import testing
from chainer.testing import attr
from chainercv.links import FasterRCNNFPNResNet101
from chainercv.links import FasterRCNNFPNResNet50
@testing.parameterize(*testing.product({
'model': [FasterRCNNFPNResNet50, FasterRCNNFPNResNet101],
'n_fg_class': [1, 5, 20],
}))
class TestFasterRCNNFPNResNet(unittest.TestCase):
def setUp(self):
self.link = self.model(n_fg_class=self.n_fg_class)
def _check_call(self):
imgs = [
np.random.uniform(-1, 1, size=(3, 48, 48)).astype(np.float32),
np.random.uniform(-1, 1, size=(3, 32, 64)).astype(np.float32),
]
x, _ = self.link.prepare(imgs)
with chainer.using_config('train', False):
self.link(self.link.xp.array(x))
@attr.slow
def test_call_cpu(self):
self._check_call()
self.assertEqual(features.dtype, np.float32)
@attr.slow
def test_call_cpu(self):
self.check_call()
@attr.gpu
@attr.slow
def test_call_gpu(self):
self.link.to_gpu()
self.check_call()
@testing.parameterize(*testing.product({
'model': [SEResNeXt50, SEResNeXt101],
'n_class': [None, 500, 1000],
'pretrained_model': ['imagenet'],
'mean': [None, np.random.uniform((3, 1, 1)).astype(np.float32)],
}))
class TestSEResNeXtPretrained(unittest.TestCase):
@attr.slow
def test_pretrained(self):
kwargs = {
'n_class': self.n_class,
'pretrained_model': self.pretrained_model,
'mean': self.mean,
}
if self.pretrained_model == 'imagenet':
valid = self.n_class in {None, 1000}
if valid:
], [
{'w_dtype': numpy.float16},
{'w_dtype': numpy.float32},
{'w_dtype': numpy.float64},
], [
{'x_dtype': numpy.int16},
{'x_dtype': numpy.int32},
{'x_dtype': numpy.int64},
]
))
@testing.fix_random()
@backend.inject_backend_tests(
None,
# ChainerX tests
testing.product({
'use_chainerx': [True],
'chainerx_device': ['native:0', 'cuda:0'],
})
# CPU tests
+ testing.product({
'use_cuda': [False],
'use_ideep': ['never', 'always'],
})
# GPU tests
+ testing.product([
[{'use_cuda': True}],
# Without cuDNN
testing.product({
'use_cudnn': ['never'],
})
# With cuDNN
self.check_double_backward(
cuda.cupy.asfortranarray(cuda.to_gpu(self.x)),
cuda.cupy.asfortranarray(cuda.to_gpu(self.gy)),
cuda.cupy.asfortranarray(cuda.to_gpu(self.ggx)))
@attr.gpu
def test_double_backward_gpu_no_cudnn(self):
self.check_double_backward(
cuda.to_gpu(self.x), cuda.to_gpu(self.gy), cuda.to_gpu(self.ggx),
'never')
@testing.parameterize(*testing.product({
'dtype': [numpy.float16, numpy.float32, numpy.float64],
'h': [5],
'k': [3],
's': [3],
'p': [0],
'cover_all': [True, False],
}))
class TestMaxPoolingUnpooling(unittest.TestCase):
def check_left_inverse(self, xp, use_cudnn='never'):
x = xp.arange(self.h * self.h).reshape(
(1, 1, self.h, self.h)).astype(self.dtype)
with chainer.using_config('use_cudnn', use_cudnn):
y = chainer.functions.unpooling_2d(
x, self.k, self.s, self.p, None, self.cover_all)
x_ = chainer.functions.max_pooling_2d(
y, self.k, self.s, self.p, self.cover_all).data
self.assertEqual(x.shape, x_.shape)
testing.assert_allclose(expect, param.array)
def test_weight_decay(self, backend_config0,
backend_config1, backend_config2):
self.check_weight_decay(
[backend_config0, backend_config1, backend_config2])
# TODO(kshitij12345): Test with chainerx when `loss_scale` in `backward`.
@testing.inject_backend_tests(
None,
# CPU tests
[{}, {'use_ideep': 'always'}]
# GPU tests
+ testing.product({
'use_cuda': [True],
})
)
class TestWeightDecayLossScale(unittest.TestCase):
def test_weight_decay_loss_scale(self, backend_config):
a = self._updated_array(backend_config, None)
b = self._updated_array(backend_config, loss_scale=4.)
testing.assert_allclose(a, b)
def _updated_array(self, backend_config, loss_scale):
arr = np.arange(3, dtype=np.float32)
param = chainer.Parameter(arr)
link = chainer.Link()
with link.init_scope():
link.p = param
import numpy
from chainer import functions
from chainer import testing
from chainer import utils
@testing.parameterize(*testing.product({
'shape': [(3, 2), ()],
'dtype': [numpy.float16, numpy.float32, numpy.float64],
}))
@testing.fix_random()
@testing.inject_backend_tests(
None,
# CPU tests
[
{},
]
# GPU tests
+ testing.product({
'use_cuda': [True],
'cuda_device': [0, 1],
})
# ChainerX tests
+ [
{'use_chainerx': True, 'chainerx_device': 'native:0'},
{'use_chainerx': True, 'chainerx_device': 'cuda:0'},
{'use_chainerx': True, 'chainerx_device': 'cuda:1'},
])
class TestSign(testing.FunctionTestCase):
'dtype': numpy.float64,
'forward_options': {},
'backward_options': {
'eps': 1e-3,
'rtol': 1e-2,
'atol': 1e-2
},
'double_backward_options': {
'eps': 1e-3,
'rtol': 1e-3,
'atol': 1e-3
}
},
],
testing.product({
'shape': [(), (3, )],
'reduce': ['no'],
}) + testing.product({
'shape': [(4, 10), (2, 5, 3, 3)],
'reduce': ['no', 'sum_along_second_axis'],
}),
))
class TestHuberLoss(unittest.TestCase):
def setUp(self):
self._config_user = chainer.using_config('dtype', self.dtype)
self._config_user.__enter__()
self.x = utils.force_array((numpy.random.random(self.shape) - 0.5) * 3,
self.dtype)
self.t = utils.force_array((numpy.random.random(self.shape) - 0.5),
self.dtype)
if self.reduce == 'sum_along_second_axis':
def test_product(self):
self.assertListEqual(testing.product(self.actual), self.expect)
import numpy
from operator import mul
import six
import chainer
from chainer.backends import cuda
from chainer import functions
from chainer import testing
from chainer.testing import attr
from chainer.utils import conv
from chainer_tests.functions_tests.pooling_tests import pooling_nd_helper
@testing.parameterize(*testing.product({
'in_dims': [(4, ), (4, 3), (4, 3, 2), (1, 1, 1, 1)],
'cover_all': [True, False],
'dtype': [numpy.float16, numpy.float32, numpy.float64],
}))
@testing.inject_backend_tests(
None,
# CPU tests
[
{},
{
'use_ideep': 'always'
},
]
# GPU tests
+ testing.product({
'use_cuda': [True],
'use_cudnn': ['never', 'always'],
import unittest
import numpy
import chainer
from chainer import cuda
from chainer import functions
from chainer import testing
from chainer.testing import attr
@testing.parameterize(*testing.product({
'in_shape': [(4, 3, 2)],
'out_shape': [(2, 2, 6), (2, -1, 6)],
'dtype': [numpy.float16, numpy.float32, numpy.float64],
}))
class TestReshape(unittest.TestCase):
def setUp(self):
self.x = numpy.random.uniform(-1, 1, self.in_shape).astype(self.dtype)
def check_forward(self, x_data):
shape = self.out_shape
x = chainer.Variable(x_data)
y = functions.reshape(x, shape)
self.assertEqual(y.data.dtype, self.dtype)
self.assertTrue((self.x.reshape(shape) == cuda.to_cpu(y.data)).all())
def test_forward_cpu(self):
self.check_forward(self.x)
self.assertIsInstance(out_0, np.ndarray)
self.assertIsInstance(out_1, np.ndarray)
def test_cpu(self):
self.check(self.x)
@attr.gpu
def test_gpu(self):
self.link.to_gpu()
self.check(self.x)
@testing.parameterize(*testing.product({
'crop': ['center', '10'],
'crop_size': [192, (192, 256), (256, 192)],
'scale_size': [None, 256, (256, 256)],
'in_channels': [1, 3],
'mean': [None, np.float32(1)]
}))
class TestFeaturePredictor(unittest.TestCase):
def setUp(self):
self.link = FeaturePredictor(DummyFeatureExtractor(
self.in_channels, (1, ), None),
crop_size=self.crop_size,
scale_size=self.scale_size,
crop=self.crop,
mean=self.mean)
if isinstance(self.crop_size, int):
hw = (self.crop_size, self.crop_size)
import chainer
from chainer import cuda
from chainer import functions
from chainer import testing
from chainer.testing import attr
@testing.inject_backend_tests(
None,
# CPU tests
[
{},
]
# GPU tests
+ testing.product({
'use_cuda': [True],
'cuda_device': [0, 1],
})
# ChainerX tests
+ testing.product({
'use_chainerx': [True],
'chainerx_device': ['native:0', 'cuda:0', 'cuda:1'],
})
)
@testing.parameterize(*testing.product({
'train': [True, False],
'shape': [(3, 2), ()],
'dtype': [numpy.float16, numpy.float32, numpy.float64],
}))
class TestRReLU(testing.FunctionTestCase):
dodge_nondifferentiable = True
import unittest
import numpy
import chainer
from chainer import cuda
from chainer.functions.loss import negative_sampling
from chainer import links
from chainer import testing
from chainer.testing import attr
@testing.parameterize(*testing.product({
't': [[0, 2], [-1, 1, 2]],
'reduce': ['sum', 'no'],
}))
class TestNegativeSampling(unittest.TestCase):
in_size = 3
sample_size = 2
def setUp(self):
batch = len(self.t)
x_shape = (batch, self.in_size)
self.link = links.NegativeSampling(
self.in_size, [10, 5, 2, 5, 2], self.sample_size)
self.link.cleargrads()
self.x = numpy.random.uniform(-1, 1, x_shape).astype(numpy.float32)
self.t = numpy.array(self.t).astype(numpy.int32)
if self.reduce == 'no':
import unittest
import mock
import numpy
import chainer
from chainer import cuda
from chainer import functions
from chainer import gradient_check
from chainer import testing
from chainer.testing import attr
from chainer.testing import condition
@testing.parameterize(*testing.product({
'shape': [(3, 2), ()],
'dtype': [numpy.float16, numpy.float32, numpy.float64],
}))
class TestTanh(unittest.TestCase):
def setUp(self):
self.x = numpy.random.uniform(-.5, .5, self.shape).astype(self.dtype)
self.gy = numpy.random.uniform(-.1, .1, self.shape).astype(self.dtype)
self.check_backward_options = {}
if self.dtype == numpy.float16:
self.check_backward_options = {
'dtype': numpy.float64, 'atol': 1e-4, 'rtol': 1e-3}
def check_forward(self, x_data, use_cudnn=True):
x = chainer.Variable(x_data)
y = functions.tanh(x, use_cudnn=use_cudnn)
self.assertEqual(y.data.dtype, self.dtype)
[
{'n_layers': 1, 'hidden_size': 2,
'input_size': 1, 'batches': (1, 1, 1)},
{'n_layers': 2, 'hidden_size': 2,
'input_size': 3, 'batches': (3, 2, 1)},
{'n_layers': 4, 'hidden_size': 6,
'input_size': 3, 'batches': (5, 3, 1)},
{'n_layers': 5, 'hidden_size': 10,
'input_size': 6, 'batches': (6, 5, 3)},
]))
@testing.fix_random()
@backend.inject_backend_tests(
None,
# ChainerX tests
testing.product({
'use_chainerx': [True],
'chainerx_device': ['native:0', 'cuda:0'],
})
# CPU tests
+ testing.product({
'use_cuda': [False],
'use_ideep': ['never', 'always'],
})
# GPU tests
+ testing.product([
[{'use_cuda': True}],
testing.product({
'use_cudnn': ['always'],
'cudnn_deterministic': [True, False],
'autotune': [True, False],
})]))
if x.ndim == 2:
return numpy.linalg.inv(x)
return numpy.array([numpy.linalg.inv(ix) for ix in x])
def _make_eye(shape):
if len(shape) == 2:
n = shape[0]
return numpy.eye(n, dtype=numpy.float32)
m = shape[0]
n = shape[1]
return numpy.array([numpy.eye(n, dtype=numpy.float32)] * m)
@testing.parameterize(*testing.product({
'dtype': [numpy.float16, numpy.float32, numpy.float64],
'shape': [(1, 1), (5, 5)],
}))
@testing.fix_random()
@testing.inject_backend_tests(
None,
# CPU tests
[
{},
]
# GPU tests
+ testing.product({
'use_cuda': [True],
'cuda_device': [0, 1],
})
# ChainerX tests
+ testing.product({
with backend_config:
return self._train_linear_classifier(
model, optimizer, backend_config.use_cuda)
def accuracy_gpu(self, device):
with cuda.get_device_from_id(device):
return self.accuracy(
backend.BackendConfig({'use_cuda': True}),
device)
@backend.inject_backend_tests(
['test_linear_model'],
# CPU tests
testing.product({
'use_cuda': [False],
'use_ideep': ['never', 'always'],
})
# GPU tests
+ [{'use_cuda': True}])
class OptimizerTestBase(object):
def create(self):
raise NotImplementedError()
def setUp(self):
self.model = LinearModel(self.create(), self.dtype,
self.use_placeholder)
@condition.retry(10)
def test_linear_model(self, backend_config):
try:
y_expected_shape = (N, c) + outs
y_expected = numpy.zeros(y_expected_shape, dtype=x_data.dtype)
for i in six.moves.range(N):
for _c in six.moves.range(c):
for x in xs_iter(dims):
x_idx = (i, _c) + x
for kx in kxs_iter(x, outs, ksize, stride, pad):
y_idx = (i, _c) + kx
y_expected[y_idx] += x_data[x_idx]
return y_expected
@testing.parameterize(*(testing.product({
'dims': [(5, ), (2, 3, 4)],
'_ksize': [3],
'_stride': [3],
'_pad': [1],
'cover_all': [True],
'dtype': [numpy.float16, numpy.float32, numpy.float64],
}) + testing.product({
'dims': [(3, 2)],
'_ksize': [1, 2, 3],
'_stride': [1, 2, 3],
'_pad': [0, 1],
'cover_all': [True, False],
'dtype': [numpy.float32],
})))
class TestUnpoolingND(unittest.TestCase):
def setUp(self):
N = 2
c = 3
ndim = len(self.dims)
import chainer.functions as F
from chainer import gradient_check
from chainer import testing
from chainer.testing import attr
from chainer.testing import condition
from chainer.testing import parameterize
from chainer.utils import conv
from chainer.utils import type_check
@parameterize(*testing.product({
'dims': [(4, 3, 2), (2,)],
'dilate': [1, 2],
'groups': [1, 2],
'nobias': [False],
'test_outsize': [False],
'c_contiguous': [True],
'x_dtype': [numpy.float32],
'W_dtype': [numpy.float32],
'autotune': [True, False],
}) + testing.product({
'dims': [(3, 2)],
'dilate': [1, 2],
'groups': [1],
'nobias': [False],
'test_outsize': [False],
'c_contiguous': [True],
'x_dtype': [numpy.float16, numpy.float32, numpy.float64],
'W_dtype': [numpy.float16, numpy.float32, numpy.float64],
'autotune': [False],
}) + testing.product({
{'slices': numpy.array([False, True, False, True]),
'b_data': numpy.random.uniform(size=(2, 2, 3))},
{'slices': [], 'b_data': numpy.empty(shape=(0, 2, 3))},
]
))
@testing.fix_random()
@testing.inject_backend_tests(
None,
# CPU tests
[
{},
]
# GPU tests
+ testing.product({
'use_cuda': [True],
'use_cudnn': ['never', 'always'],
'cuda_device': [0, 1],
})
# ChainerX tests
+ testing.product({
'use_chainerx': [True],
'chainerx_device': ['native:0', 'cuda:0', 'cuda:1'],
})
)
class TestScatterAdd(testing.FunctionTestCase):
def setUp(self):
self.check_backward_options.update({'atol': 5e-4, 'rtol': 5e-4})
self.check_double_backward_options.update({
'atol': 1e-3, 'rtol': 1e-3})
def _to_fcontiguous(arrays):
xp = cuda.get_array_module(*arrays)
return [xp.asfortranarray(a) for a in arrays]
def _batch_normalization(args):
x, gamma, beta, mean, var, eps, expander = args
mean = mean[expander]
std = numpy.sqrt(var + eps)[expander]
y_expect = (gamma[expander] * (x - mean) / std + beta[expander])
return y_expect
@testing.parameterize(*(testing.product_dict(
testing.product({
'param_shape': [(3, ), (3, 4), (3, 2, 3)],
'ndim': [0, 1, 2],
}) + [
{
'input_shape': (5, 4, 3, 2),
'axis': (0, 2, 3)
},
{
'input_shape': (5, 4),
'axis': 0
},
{
'input_shape': (5, 4, 3),
'axis': (0, 1)
},
],
testing.product({
import unittest
import numpy
import six
from chainer.backends import cuda
from chainer import functions
from chainer import gradient_check
from chainer import testing
from chainer.testing import backend
@testing.parameterize(*testing.product({
'dtype': [numpy.float16, numpy.float32, numpy.float64],
}))
@backend.inject_backend_tests(
['test_forward', 'test_backward'],
# CPU tests
testing.product({
'use_cuda': [False],
'use_ideep': ['never', 'always'],
})
# GPU tests
+ [{'use_cuda': True}])
class TestLocalResponseNormalization(unittest.TestCase):
def setUp(self):
x = numpy.random.uniform(-1, 1, (2, 7, 3, 2)).astype(self.dtype)
gy = numpy.random.uniform(-1, 1, (2, 7, 3, 2)).astype(self.dtype)
self.inputs = [x]
import unittest
import numpy
import chainer
from chainer import cuda
from chainer import functions
from chainer import gradient_check
from chainer import testing
from chainer.testing import attr
@testing.parameterize(*testing.product({
'shape': [(3, 4), ()],
'dtype': [numpy.float16, numpy.float32, numpy.float64],
}))
class TestLinearInterpolate(unittest.TestCase):
def setUp(self):
self.p = numpy.random.uniform(0, 1, self.shape).astype(self.dtype)
self.x = numpy.random.uniform(-1, 1, self.shape).astype(self.dtype)
self.y = numpy.random.uniform(-1, 1, self.shape).astype(self.dtype)
self.g = numpy.random.uniform(-1, 1, self.shape).astype(self.dtype)
self.ggp = numpy.random.uniform(0, 1, self.shape).astype(self.dtype)
self.ggx = numpy.random.uniform(-1, 1, self.shape).astype(self.dtype)
self.ggy = numpy.random.uniform(-1, 1, self.shape).astype(self.dtype)
self.check_forward_options = {}
self.check_backward_options = {'dtype': numpy.float64}
self.check_double_backward_options = {
'dtype': numpy.float64,
'atol': 5e-3,
from chainer.backends import cuda
from chainer import gradient_check
from chainer import links
from chainer.serializers import npz
from chainer import testing
from chainer.testing import attr
from chainer.utils import type_check
def gen_mask(ratio, shape):
return numpy.random.rand(*shape) >= ratio
@testing.parameterize(*testing.product({
'in_shape': [(3,), (3, 2, 2)],
'x_dtype': [numpy.float16, numpy.float32, numpy.float64],
'W_dtype': [numpy.float16, numpy.float32, numpy.float64],
'use_batchwise_mask': [True, False],
}))
class TestSimplifiedDropconnect(unittest.TestCase):
out_size = 2
ratio = 0.5
def setUp(self):
in_size = numpy.prod(self.in_shape)
self.link = links.SimplifiedDropconnect(
in_size, self.out_size,
initialW=chainer.initializers.Normal(1, self.W_dtype),
initial_bias=chainer.initializers.Normal(1, self.x_dtype))
self.link.cleargrads()
'fan_option': None
}, {
'target': initializers.LeCunNormal,
'fan_option': None
}, {
'target': initializers.GlorotNormal,
'fan_option': None
}, {
'target': initializers.HeNormal,
'fan_option': 'fan_in'
}, {
'target': initializers.HeNormal,
'fan_option': 'fan_out'
}],
testing.product({
'shape': [(2, 3), (2, 3, 4)],
'dtype': [numpy.float16, numpy.float32, numpy.float64]
}))))
class NormalBase(unittest.TestCase):
def setUp(self):
pass
def check_initializer(self, w):
if self.fan_option is None:
initializer = self.target(scale=0.1)
else:
initializer = self.target(scale=0.1, fan_option=self.fan_option)
initializer(w)
self.assertTupleEqual(w.shape, self.shape)
self.assertEqual(w.dtype, self.dtype)
def test_initializer_cpu(self):
import chainer
from chainer import cuda
from chainer.functions import convolution_2d
from chainer.functions import deformable_convolution_2d_sampler
from chainer import utils
from chainer import testing
from chainer.testing import attr
@testing.parameterize(*testing.product({
'params': [
(1, 1, 1, 1, 1, 1),
(2, 2, 2, 2, 2, 2),
(1, 2, 2, 1, 1, 2),
(1, 2, 3, 4, 1, 2),
(1, 2, 3, 4, 4, 5),
(3, 3, 2, 2, 1, 1),
],
'use_cudnn': ['always', 'never']
}))
class TestDeformableConvolution2DSamplerFunctionZeroOffset(unittest.TestCase):
def setUp(self):
in_channels = 3
out_channels = 2
batch_size = 2
h = 9
w = 9
kh, kw, sy, sx, ph, pw = self.params
@testing.parameterize(*testing.product({
# repeats is any of (int, bool or tuple) and
# axis is any of (int or None).
'params': (
# Repeats 1-D array
testing.product({
'shape': [(2, )],
'repeats': [0, 1, 2, True, (0, ), (1, ), (2, ), (True, )],
'axis': [None, 0],
}) +
# Repeats 2-D array (with axis=None)
testing.product({
'shape': [(3, 2)],
'repeats': [4, (4, ), (4, ) * 6, (True, ) * 6],
'axis': [None],
}) +
# Repeats 2-D array (with axis=0)
testing.product({
'shape': [(3, 2)],
'repeats': [5, (5, ), (5, ) * 3],
'axis': [0],
}) +
# Repeats 2-D array (with axis=1)
testing.product({
'shape': [(3, 2)],
'repeats': [5, (5, ), (5, ) * 2],
'axis': [1],
}) +
# Repeats 3-D array (with axis=-2)
testing.product({
'shape': [(3, 2, 4)],
'repeats': [5, (5, ), (5, ) * 2],
'axis': [-2],
})),
'dtype': [numpy.float16, numpy.float32, numpy.float64],
}))
import unittest
import numpy
import chainer
from chainer.backends import cuda
from chainer import functions
from chainer import gradient_check
from chainer import testing
from chainer.testing import attr
@testing.parameterize(*testing.product({
'x_dtype': [numpy.float16, numpy.float32, numpy.float64],
'W_dtype': [numpy.float16, numpy.float32, numpy.float64],
'ratio': [0.0, 0.9],
'train': [True, False],
'use_batchwise_mask': [True, False],
}))
class TestSimplifiedDropconnect(unittest.TestCase):
def setUp(self):
self.W = numpy.random.uniform(
-1, 1, (2, 3)).astype(self.W_dtype)
self.b = numpy.random.uniform(
-1, 1, 2).astype(self.x_dtype)
self.x = numpy.random.uniform(-1, 1, (4, 3)).astype(self.x_dtype)
self.gy = numpy.random.uniform(-1, 1, (4, 2)).astype(self.x_dtype)
self.ggW = numpy.random.uniform(
-1, 1, (2, 3)).astype(self.W_dtype)
from __future__ import division
from __future__ import absolute_import
from builtins import * # NOQA
from future import standard_library
standard_library.install_aliases() # NOQA
import mock
import unittest
from chainer import testing
import chainerrl
@testing.parameterize(*testing.product({
'max_episode_steps': [1, 2, 3],
}))
class TestContinuingTimeLimit(unittest.TestCase):
def test(self):
env = mock.Mock()
env.reset.side_effect = ['state'] * 2
# Since info dicts are modified by the wapper, each step call needs to
# return a new info dict.
env.step.side_effect = [('state', 0, False, {}) for _ in range(6)]
env = chainerrl.wrappers.ContinuingTimeLimit(
env, max_episode_steps=self.max_episode_steps)
env.reset()
for t in range(2):
_, _, done, info = env.step(0)
if t + 1 >= self.max_episode_steps:
from chainer.testing import attr
@testing.parameterize(*testing.product_dict(
[
{'shape': None, 'axis': 1},
{'shape': (5,), 'axis': 0},
{'shape': (2, 3), 'axis': 0},
{'shape': (2, 3), 'axis': 1},
{'shape': (2, 3, 4), 'axis': 0},
{'shape': (2, 3, 4), 'axis': -1},
{'shape': (2, 3, 2, 3), 'axis': -3},
{'shape': (2, 3, 2, 3), 'axis': 3},
],
testing.product({
'dtype': [numpy.float16, numpy.float32, numpy.float64],
}),
))
@testing.fix_random()
@testing.inject_backend_tests(
None,
# CPU tests
[
{},
{'use_ideep': 'always'},
]
# GPU tests
+ testing.product({
'use_cuda': [True],
'cuda_device': [0, 1],
})
import unittest
import numpy
import chainer
from chainer import cuda
from chainer import functions
from chainer import gradient_check
from chainer import testing
from chainer.testing import attr
from chainer.testing import condition
@testing.parameterize(*testing.product({
'axis': [None, 0, 1, 2, -1, (0, 1), (1, 0), (0, -1), (-2, 0)],
'keepdims': [True, False],
'dtype': [numpy.float16, numpy.float32, numpy.float64],
}))
class TestSum(unittest.TestCase):
def setUp(self):
self.x = numpy.random.uniform(-1, 1, (3, 2, 4)).astype(self.dtype)
g_shape = self.x.sum(axis=self.axis, keepdims=self.keepdims).shape
self.gy = numpy.random.uniform(-1, 1, g_shape).astype(self.dtype)
def check_forward(self, x_data):
x = chainer.Variable(x_data)
y = functions.sum(x, axis=self.axis, keepdims=self.keepdims)
self.assertEqual(y.data.dtype, self.dtype)
y_expect = self.x.sum(axis=self.axis, keepdims=self.keepdims)
from chainer.testing import condition
def _batch_normalization(expander, gamma, beta, x, mean, var, eps, test):
mean = mean[expander]
if test:
std = numpy.sqrt(var[expander])
else:
std = numpy.sqrt(var[expander] + eps)
y_expect = gamma * (x - mean) / std + beta
return y_expect
@testing.parameterize(*testing.product({
'test': [True, False],
'volatile': ['on', 'off'],
'ndim': [0, 1, 2, 3],
'dtype': [numpy.float16, numpy.float32, numpy.float64],
}))
class BatchNormalizationTest(unittest.TestCase):
def setUp(self):
self.expander = (None, Ellipsis) + (None,) * self.ndim
self.aggr_axes = (0,) + tuple(six.moves.range(2, self.ndim + 2))
self.link = links.BatchNormalization(3, dtype=self.dtype)
gamma = self.link.gamma.data
gamma[...] = numpy.random.uniform(.5, 1, gamma.shape)
beta = self.link.beta.data
beta[...] = numpy.random.uniform(-1, 1, beta.shape)
self.link.zerograds()
from chainer.utils import type_check
def _batch_normalization(expander, gamma, beta, x, mean, var, eps, test):
mean = mean[expander]
if test:
std = numpy.sqrt(var[expander])
else:
std = numpy.sqrt(var[expander] + eps)
y_expect = gamma * (x - mean) / std + beta
return y_expect
@testing.parameterize(*(testing.product({
'test': [True, False],
'volatile': ['on'],
'ndim': [0],
'dtype': [numpy.float32],
}) + testing.product({
'test': [True, False],
'volatile': ['off'],
'ndim': [0, 1, 2, 3],
'dtype': [numpy.float16, numpy.float32, numpy.float64],
})))
class BatchNormalizationTest(unittest.TestCase):
def setUp(self):
self.expander = (None, Ellipsis) + (None, ) * self.ndim
self.aggr_axes = (0, ) + tuple(six.moves.range(2, self.ndim + 2))
self.link = links.BatchNormalization(3, dtype=self.dtype)
gamma = self.link.gamma.data
gamma[...] = numpy.random.uniform(.5, 1, gamma.shape)
import unittest
import numpy
import chainer
from chainer.backends import cuda
from chainer import functions
from chainer import gradient_check
from chainer import testing
from chainer.testing import attr
from chainer.testing import condition
@testing.parameterize(*testing.product({
'axis': [None, 0, 1, 2, -1, (0, 1), (1, 0), (0, -1), (-2, 0)],
'keepdims': [True, False],
'dtype': [numpy.float16, numpy.float32, numpy.float64],
}))
class TestSum(unittest.TestCase):
def setUp(self):
self.x = numpy.random.uniform(-1, 1, (3, 2, 4)).astype(self.dtype)
g_shape = self.x.sum(axis=self.axis, keepdims=self.keepdims).shape
self.gy = numpy.random.uniform(-1, 1, g_shape).astype(self.dtype)
def check_forward(self, x_data):
x = chainer.Variable(x_data)
y = functions.sum(x, axis=self.axis, keepdims=self.keepdims)
self.assertEqual(y.data.dtype, self.dtype)
y_expect = self.x.sum(axis=self.axis, keepdims=self.keepdims)
import mock
import numpy
import six
import chainer
from chainer import cuda
from chainer import functions
from chainer import gradient_check
from chainer import testing
from chainer.testing import attr
from chainer.testing import condition
@testing.parameterize(*testing.product({
'dtype': [numpy.float16, numpy.float32, numpy.float64],
}))
class TestAveragePooling2D(unittest.TestCase):
def setUp(self):
self.x = numpy.random.uniform(-1, 1, (2, 3, 4, 3)).astype(self.dtype)
self.gy = numpy.random.uniform(-1, 1, (2, 3, 2, 2)).astype(self.dtype)
self.check_forward_options = {}
self.check_backward_options = {'eps': 1e-2}
if self.dtype == numpy.float16:
self.check_forward_options = {'atol': 5e-4, 'rtol': 5e-3}
self.check_backward_options = {
'eps': 1e-1,
'atol': 5e-3,
'rtol': 5e-2
}
import unittest
import numpy
import chainer
from chainer.backends import cuda
from chainer import functions
from chainer import gradient_check
from chainer import testing
from chainer.testing import attr
@testing.parameterize(*testing.product({
'shape': [None, (2, 3), (2, 2, 3), (2, 2, 2, 3)],
'dtype': [numpy.float16, numpy.float32, numpy.float64],
}))
@testing.fix_random()
class TestLogSoftmax(unittest.TestCase):
def setUp(self):
if self.shape is None:
# For checking numerical stability
value = -5 if self.dtype == numpy.float16 else -1000
self.x = numpy.array([[value, 1]], dtype=self.dtype)
else:
self.x = numpy.random.uniform(-1, 1, self.shape).astype(self.dtype)
self.gy = numpy.random.uniform(-1, 1, self.x.shape).astype(self.dtype)
self.ggx = numpy.random.uniform(-1, 1, self.x.shape).astype(self.dtype)
self.check_forward_options = {}
self.check_backward_options = {}
self.assertIs(ret, 10)
def test_serialize_none(self):
ret = self.serializer('x', None)
dset = self.serializer.target['x']
self.assertIsInstance(dset, numpy.ndarray)
self.assertEqual(dset.shape, ())
self.assertEqual(dset.dtype, numpy.object)
self.assertIs(dset[()], None)
self.assertIs(ret, None)
@testing.parameterize(*testing.product({'compress': [False, True]}))
class TestNpzDeserializer(unittest.TestCase):
def setUp(self):
self.data = numpy.random.uniform(-1, 1, (2, 3)).astype(numpy.float32)
fd, path = tempfile.mkstemp()
os.close(fd)
self.temp_file_path = path
with open(path, 'wb') as f:
savez = numpy.savez_compressed if self.compress else numpy.savez
savez(
f, **{
'x/': None,
'y': self.data,
'z': numpy.asarray(10),
'w': None
mean = chainer.functions.mean(x, axis=axis, keepdims=True)
std = chainer.functions.sqrt(
eps +
chainer.functions.mean(
chainer.functions.square(x - mean),
axis=axis, keepdims=True))
r = (std.array / avg_std).clip(1./rmax, rmax)
d = ((mean.array - avg_mean) / avg_std).clip(-dmax, dmax)
xhat = ((x - mean) / std) * r + d
return gamma * xhat + beta
@testing.parameterize(*(testing.product({
'ndim': [0, 1, 2],
'eps': [2e-5, 1e-1],
'dtype': [numpy.float32],
}) + testing.product({
'ndim': [1],
'eps': [2e-5, 1e-1],
'dtype': [numpy.float16, numpy.float32, numpy.float64],
})))
class TestBatchRenormalization(unittest.TestCase):
def setUp(self):
self.expander = (None, Ellipsis) + (None,) * self.ndim
self.aggr_axes = (0,) + tuple(six.moves.range(2, self.ndim + 2))
self.decay = 0.9
self.rmax = self.dtype(3)
self.dmax = self.dtype(5)
},
{
'shape': (2, 3, 4),
'axis': -2
},
{
'shape': (2, 3, 4),
'axis': -1
},
{
'shape': (2, 3, 4),
'axis': None
},
],
testing.product({
'dtype': [numpy.float16, numpy.float32, numpy.float64],
'contain_zero': [True, False],
}),
) + testing.product({
'shape': [(0, 3)],
'axis': [-2, 1, None],
'dtype': [numpy.float64],
'contain_zero': [False],
})))
class TestCumprod(unittest.TestCase):
def setUp(self):
self.x = numpy.random.uniform(-2, 2, self.shape).astype(self.dtype)
if self.contain_zero:
index = numpy.random.choice(self.x.size)
self.x.ravel()[index] = 0
self.gy = numpy.random.uniform(-1, 1, self.shape).astype(self.dtype)
self.ggx = numpy.random.uniform(-1, 1, self.shape).astype(self.dtype)
import unittest
import numpy
import six
import chainer
from chainer.backends import cuda
from chainer import testing
from chainer.testing import attr
from chainer.utils import type_check
@testing.parameterize(*testing.product({
'shape': [(9, 11), (99,)],
'dtype': [numpy.float16, numpy.float32, numpy.float64],
'label_dtype': [numpy.int8, numpy.int16, numpy.int32, numpy.int64],
}))
class TestBinaryAccuracy(unittest.TestCase):
def setUp(self):
self.x = numpy.random.uniform(-1, 1, self.shape).astype(self.dtype)
self.t = numpy.random.randint(-1, 2, self.shape).astype(
self.label_dtype)
self.check_forward_options = {}
if self.dtype == numpy.float16:
self.check_forward_options = {'atol': 1e-4, 'rtol': 1e-3}
def check_forward(self, x_data, t_data):
x = chainer.Variable(x_data)
t = chainer.Variable(t_data)
y = chainer.functions.binary_accuracy(x, t)
# Not under git control
with work_dir(tmp):
self.assertFalse(chainerrl.experiments.is_under_git_control())
# Run: git init
with work_dir(tmp):
subprocess.call(['git', 'init'])
# Under git control
with work_dir(tmp):
self.assertTrue(chainerrl.experiments.is_under_git_control())
@testing.parameterize(*testing.product({
'git': [True, False],
'user_specified_dir': [tempfile.mkdtemp(), None],
'argv': [['command', '--option'], None],
'time_format': ['%Y%m%dT%H%M%S.%f', '%Y%m%d'],
}))
class TestPrepareOutputDir(unittest.TestCase):
def test_prepare_output_dir(self):
tmp = tempfile.mkdtemp()
args = dict(a=1, b='2')
os.environ['CHAINERRL_TEST_PREPARE_OUTPUT_DIR'] = 'T'
with work_dir(tmp):
if self.git:
subprocess.call(['git', 'init'])
with open('not_utf-8.txt', 'wb') as f:
def __getitem__(self, key):
raise NotImplementedError
def __call__(self, key, value):
if value is None:
value = self.target[key]
elif isinstance(value, numpy.ndarray):
numpy.copyto(value, self.target[key])
else:
value = type(value)(numpy.asarray(self.target[key]))
return value
@testing.parameterize(*testing.product({
'n_prefetch': [1, 2],
'shared_mem': [None, 1000000],
}))
class TestMultiprocessIterator(unittest.TestCase):
def setUp(self):
self.n_processes = 2
self.options = {'n_processes': self.n_processes,
'n_prefetch': self.n_prefetch,
'shared_mem': self.shared_mem}
def test_iterator_repeat(self):
dataset = [1, 2, 3, 4, 5, 6]
it = iterators.MultiprocessIterator(dataset, 2, **self.options)
for i in range(3):
self.assertEqual(it.epoch, i)
self.assertAlmostEqual(it.epoch_detail, i + 0 / 6)
from chainer import gradient_check
from chainer import testing
from chainer.testing import array
from chainer.testing import attr
from chainer.testing import condition
from chainer.testing import parameterize
from chainer.utils import conv
from chainer.utils import type_check
@parameterize(*testing.product({
'dims': [(4, 3, 2), (2, )],
'dilate': [1, 2],
'groups': [1, 2],
'nobias': [False],
'test_outsize': [False],
'c_contiguous': [True],
'x_dtype': [numpy.float32],
'W_dtype': [numpy.float32],
'autotune': [True, False],
}) + testing.product({
'dims': [(3, 2)],
'dilate': [1, 2],
'groups': [1],
'nobias': [False],
'test_outsize': [False],
'c_contiguous': [True],
'x_dtype': [numpy.float16, numpy.float32, numpy.float64],
'W_dtype': [numpy.float16, numpy.float32, numpy.float64],
'autotune': [False],
}) + testing.product({
def clear(self):
self.loss = None
self.accuracy = None
def __call__(self, x, t):
h = chainer.functions.relu(self.conv(x))
y = self.fc(h)
self.loss = chainer.functions.softmax_cross_entropy(y, t)
self.accuracy = chainer.functions.accuracy(y, t)
return self.loss
@testing.parameterize(*testing.product({
'dtype': [numpy.float32, numpy.float16],
}))
class TestGatherScatter(unittest.TestCase):
def setUp(self):
pass
@attr.gpu
def test_gather_scatter_grads(self):
cupy = cuda.cupy
model0 = SimpleNet(dtype=self.dtype)
model1 = copy.deepcopy(model0)
model0.to_gpu()
model1.to_gpu()
testing.product([
[
{
'dtype': numpy.float16
},
{
'dtype': numpy.float32
},
{
'dtype': numpy.float64
},
],
[
{
'shape': (4, 15),
'axis': 1
},
{
'shape': (4, ),
'axis': 0
},
{
'shape': (4, 3, 2, 5),
'axis': 0
},
{
'shape': (4, 3, 2, 5),
'axis': 1
},
{
'shape': (4, 3, 2, 5),
'axis': 2
},
{
'shape': (4, 3, 2, 5),
'axis': 3
},
{
'shape': (4, 3, 2),
'axis': (0, 1)
},
{
'shape': (4, 3, 2, 4, 3, 2, 2),
'axis': (1, 4, 3, 6)
},
{
'shape': (0, 2),
'axis': 1
},
{
'shape': (),
'axis': ()
},
],
[
# nonzeros (optional int): number of nonzero elems in input
# truezero (bool): flag whether zero elems are exactly zero. If false,
# randomly-chosen small values are used.
{
'eps': 1e-5,
'nonzeros': None
},
{
'eps': 1e-1,
'nonzeros': None
},
{
'eps': 1e-1,
'nonzeros': 0,
'truezero': True
},
{
'eps': 1e-1,
'nonzeros': 0,
'truezero': False
},
{
'eps': 1e-1,
'nonzeros': 2,
'truezero': True
},
{
'eps': 1e-1,
'nonzeros': 2,
'truezero': False
},
],
])))
return x.reshape(len(x), -1)
def _maxout(x, W, b):
W_r = numpy.rollaxis(W, 2)
y = numpy.tensordot(_as_mat(x), W_r, axes=1)
if b is not None:
y += b
return numpy.max(y, axis=2)
@testing.parameterize(
*testing.product(
{'in_shape': [(2, ), (2, 5)],
'pool_size': [3],
'out_size': [4],
'wscale': [1],
'initial_bias': ['random', 'scalar', None],
'batchsize': [7]}
)
)
class TestMaxout(unittest.TestCase):
def setUp(self):
# x, W, and b are set so that the result of forward
# propagation gets stable, meaning that their small pertubations
# do not change :math:`argmax_{j} W_{ij\cdot} x + b_{ij}`.
x_shape = (self.batchsize, ) + self.in_shape
self.x = numpy.random.uniform(
-0.05, 0.05, x_shape).astype(numpy.float32) + 1
self.gy = numpy.random.uniform(
if x.ndim == 2:
return numpy.linalg.inv(x)
return numpy.array([numpy.linalg.inv(ix) for ix in x])
def _make_eye(shape):
if len(shape) == 2:
n = shape[0]
return numpy.eye(n, dtype=numpy.float32)
m = shape[0]
n = shape[1]
return numpy.array([numpy.eye(n, dtype=numpy.float32)] * m)
@testing.parameterize(*testing.product({
'shape': [(1, 1), (5, 5)],
}))
class InvFunctionTest(unittest.TestCase):
def setUp(self):
self.x = (numpy.eye(self.shape[-1]) +
numpy.random.uniform(-0.01, 0.01, self.shape)).astype(
numpy.float32)
self.gy = numpy.random.uniform(-1, 1, self.shape).astype(numpy.float32)
def check_forward(self, x_data, atol=1e-7, rtol=1e-7):
x = chainer.Variable(x_data)
y = functions.inv(x)
gradient_check.assert_allclose(
_inv(self.x), y.data, atol=atol, rtol=rtol)
def check_backward(self, x_data, y_grad, **kwargs):
