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
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_dict(
[
{'shape': (1,), 'axis': 0},
{'shape': (2, 3, 4), 'axis': 0},
{'shape': (2, 3, 4), 'axis': 1},
{'shape': (2, 3, 4), 'axis': 2},
{'shape': (2, 3, 4), 'axis': -3},
{'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):
def test_product_dict(self):
self.assertListEqual(testing.product_dict(*self.actual), self.expect)
testing.product_dict(
[{
'pred_bboxes': [
[[0, 0, 1, 1], [0, 0, 2, 2], [0.3, 0.3, 0.5, 0.5]],
],
'pred_labels': [
[0, 0, 0],
],
'pred_scores': [
[0.8, 0.9, 1],
],
'gt_bboxes': [
[[0, 0, 1, 0.9]],
],
'gt_labels': [
[0],
],
}],
[
{
'iou_thresh': 0.5,
'prec': [
[0, 0, 1 / 3],
],
'rec': [
[0, 0, 1],
],
},
{
'iou_thresh': 0.97,
'prec': [
[0, 0, 0],
],
'rec': [
[0, 0, 0],
],
},
]
) +
from chainer.testing import attr
@testing.parameterize(*testing.product_dict(
[
{'shape': (2, 7, 3), 'axis': 1,
'slices': [[slice(None), slice(None, 2)], [slice(None), slice(2, 5)],
[slice(None), slice(5, None)]]},
{'shape': (7, 3), 'axis': 0,
'slices': [slice(None, 2), slice(2, 5), slice(5, None)]},
{'shape': (2,), 'axis': 0, 'slices': [slice(None, 1), slice(1, None)]},
{'shape': (2,), 'axis': 0, 'slices': [()]},
{'shape': (2, 7, 3), 'axis': 1,
'slices': [[slice(None), slice(None, 2)], [slice(None), slice(2, 5)],
[slice(None), slice(5, None)]]},
{'shape': (2, 7, 3), 'axis': 1,
'slices': [[slice(None), slice(None, 2)], [slice(None), slice(2, 5)],
[slice(None), slice(5, None)]]},
{'shape': (2, 7, 3), 'axis': -2,
'slices': [[slice(None), slice(None, 2)], [slice(None), slice(2, 5)],
[slice(None), slice(5, None)]]},
],
[
{'dtype': numpy.float16},
{'dtype': numpy.float32},
{'dtype': numpy.float64},
],
))
class TestConcat(unittest.TestCase):
def setUp(self):
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_dict(
[
{'shape': (2, 3, 4), 'y_shape': (2, 6, 4), 'xs_length': 2},
{'shape': (3, 4), 'y_shape': (3, 8), 'xs_length': 2},
{'shape': (3), 'y_shape': (6,), 'xs_length': 2},
{'shape': (), 'y_shape': (2,), 'xs_length': 2},
{'shape': (2, 3, 4), 'y_shape': (2, 3, 4), 'xs_length': 1},
{'shape': (3, 4), 'y_shape': (3, 4), 'xs_length': 1},
{'shape': (3), 'y_shape': (3,), 'xs_length': 1},
{'shape': (), 'y_shape': (1,), 'xs_length': 1},
],
[
{'dtype': numpy.float16},
{'dtype': numpy.float32},
{'dtype': numpy.float64},
]
))
class TestHstack(unittest.TestCase):
def setUp(self):
self.xs = [
numpy.random.uniform(-1, 1, self.shape).astype(self.dtype)
for i in six.moves.range(self.xs_length)
]
@condition.retry(10)
def test_cpu(self):
self.check_backward(self.x, self.gy)
@attr.gpu
@condition.retry(10)
def test_gpu(self):
self.check_backward(cuda.to_gpu(self.x), cuda.to_gpu(self.gy))
@testing.parameterize(
*testing.product_dict(
[
{"left_const": False, "right_const": False},
{"left_const": True, "right_const": False},
{"left_const": False, "right_const": True},
],
[{"dtype": numpy.float16}, {"dtype": numpy.float32}, {"dtype": numpy.float64}],
)
)
class TestMatMulVarVar(unittest.TestCase):
def setUp(self):
self.x = numpy.random.uniform(-1, 1, (3, 2)).astype(self.dtype)
self.y = numpy.random.uniform(-1, 1, (2, 4)).astype(self.dtype)
self.gz = numpy.random.uniform(-1, 1, (3, 4)).astype(self.dtype)
def check_forward(self, x_data, y_data):
if self.left_const:
x = x_data
else:
x = chainer.Variable(x_data)
@testing.parameterize(*testing.product_dict(
[
{'shape': (2, 7, 3), 'axis': 1, 'ys_section': [2, 5],
'slices': [
(slice(None), slice(None, 2)),
(slice(None), slice(2, 5)),
(slice(None), slice(5, None))]},
{'shape': (7, 3), 'axis': 0, 'ys_section': [2, 5],
'slices': [slice(None, 2), slice(2, 5), slice(5, None)]},
{'shape': (7, 0), 'axis': 0, 'ys_section': [2, 5],
'slices': [slice(None, 2), slice(2, 5), slice(5, None)]},
{'shape': (2, 9, 3), 'axis': 1, 'ys_section': 3,
'slices': [
(slice(None), slice(None, 3)),
(slice(None), slice(3, 6)),
(slice(None), slice(6, None))]},
{'shape': (2, 6, 3), 'axis': 1, 'ys_section': 3,
'slices': [
(slice(None), slice(None, 2)),
(slice(None), slice(2, 4)),
(slice(None), slice(4, None))]},
{'shape': (2,), 'axis': 0, 'ys_section': [1],
'slices': [slice(None, 1), slice(1, None)]},
{'shape': (2,), 'axis': 0, 'ys_section': [],
'slices': [slice(None, None)]},
{'shape': (2, 7, 3), 'axis': 1, 'ys_section': [2, 5],
'slices': [
(slice(None), slice(None, 2)),
(slice(None), slice(2, 5)),
(slice(None), slice(5, None))]},
{'shape': (2, 7, 3), 'axis': 1, 'ys_section': [0],
'slices': [
(slice(None), slice(None, 0)),
(slice(None), slice(0, 7))]
},
{'shape': (2, 7, 3), 'axis': 1, 'ys_section': [7],
'slices': [
(slice(None), slice(None, 7)),
(slice(None), slice(7, 7))]
},
{'shape': (2, 7, 3, 2), 'axis': 1, 'ys_section': [2, 5],
'slices': [
(slice(None), slice(None, 2)),
(slice(None), slice(2, 5)),
(slice(None), slice(5, None))]},
{'shape': (2, 7, 3, 2), 'axis': 1, 'ys_section': [0],
'slices': [
(slice(None), slice(None, 0)),
(slice(None), slice(0, 7))]
},
{'shape': (10, 4, 3, 2), 'axis': 0, 'ys_section': 1,
'slices': [slice(None, None)]
},
{'shape': (10, 4, 3, 2), 'axis': 0, 'ys_section': 2,
'slices': [slice(None, 5), slice(5, None)]
},
{'shape': (10, 4, 3, 2), 'axis': 0, 'ys_section': [],
'slices': [slice(None, None)]
},
{'shape': (10, 4, 3, 2), 'axis': 0, 'ys_section': [0, 5],
'slices': [slice(0, 0), slice(0, 5), slice(5, None)]
},
{'shape': (10, 4, 3, 2), 'axis': 0, 'ys_section': [0, 0, 5],
'slices': [slice(0, 0), slice(0, 0), slice(None, 5), slice(5, None)]
},
{'shape': (10, 4, 3, 2), 'axis': 0, 'ys_section': [2, 3, 5],
'slices': [slice(None, 2), slice(2, 3), slice(3, 5), slice(5, None)]
},
{'shape': (10, 4, 3, 2), 'axis': 0,
'ys_section': numpy.asarray([2, 3, 5]),
'slices': [slice(None, 2), slice(2, 3), slice(3, 5), slice(5, None)]
},
{'shape': (10, 4, 3, 2), 'axis': 0, 'ys_section': [2, 3, 3, 5],
'slices': [slice(None, 2), slice(2, 3), slice(3, 3), slice(3, 5),
slice(5, None)]
},
{'shape': (5, 5, 3, 8), 'axis': 3, 'ys_section': 2,
'slices': [
(slice(None, None), slice(None, None), slice(None, None),
slice(None, 4)),
(slice(None, None), slice(None, None), slice(None, None),
slice(4, None))]
},
{'shape': (5, 8, 3, 2), 'axis': -3, 'ys_section': 2,
'slices': [(slice(None, None), slice(None, 4)),
(slice(None, None), slice(4, None))]
},
{'shape': (5, 8, 3, 2), 'axis': 1, 'ys_section': 2,
'slices': [(slice(None, None), slice(None, 4)),
(slice(None, None), slice(4, None))]
},
{'shape': (5, 4, 3, 4), 'axis': -1, 'ys_section': 2,
'slices': [
(slice(None, None), slice(None, None), slice(None, None),
slice(None, 2)),
(slice(None, None), slice(None, None), slice(None, None),
slice(2, None))]
},
{'shape': (10, 4, 3, 2), 'axis': 0, 'ys_section': numpy.array([]),
'slices': [slice(None, None)]
},
],
[
{'dtype': numpy.float16},
{'dtype': numpy.float32},
{'dtype': numpy.float64},
],
))
@testing.parameterize(*testing.product_dict(
[
{'subscripts': 'ij,jk->ik', 'shapes': ((2, 3), (3, 4))},
{'subscripts': ',ij->i', 'shapes': ((), (3, 4),)},
{'subscripts': 'kj,ji->ik', 'shapes': ((2, 3), (3, 4))},
{'subscripts': 'ij,jk,kl->il', 'shapes': ((5, 2), (2, 3), (3, 4))},
{'subscripts': 'ij,ij->i', 'shapes': ((2, 3), (2, 3))},
{'subscripts': 'ij,jk', 'shapes': ((2, 3), (3, 4))},
{'subscripts': 'i->', 'shapes': ((3,),)},
{'subscripts': 'ii', 'shapes': ((2, 2),)},
{'subscripts': 'ii->i', 'shapes': ((2, 2),)},
{'subscripts': 'j,j', 'shapes': ((3,), (3))},
{'subscripts': 'j,ij', 'shapes': ((3,), (2, 3))},
{'subscripts': 'j,iij', 'shapes': ((3,), (2, 2, 3))},
{'subscripts': 'iij,kkj', 'shapes': ((2, 2, 3), (4, 4, 3))},
{'subscripts': '...ij,...jk->...ik',
'shapes': ((2, 1, 2, 3), (2, 1, 3, 4))},
{'subscripts': 'i...j,jk...->k...i', 'shapes': ((4, 2, 3), (3, 5, 2))},
{'subscripts': 'ii...,...jj', 'shapes': ((2, 2, 4), (4, 3, 3))},
{'subscripts': '...i,i', 'shapes': ((2, 2, 3), (3,))},
{'subscripts': 'i...,i->...i', 'shapes': ((3, 2, 2), (3,))},
{'subscripts': 'i,ji,i', 'shapes': ((3,), (2, 3), (3,))},
{'subscripts': 'i,i,i->i', 'shapes': ((3,), (3,), (3,))},
],
testing.product({
'dtype': [numpy.float16, numpy.float32, numpy.float64],
'subscript_type': ['str', 'int'],
}),
))
class TestEinSum(unittest.TestCase):
def test_product_dict(self):
self.assertListEqual(testing.product_dict(*self.actual), self.expect)
'use_ideep': ['never', 'always'],
}) +
# GPU tests
[{'use_cuda': True}])
return decorator
@testing.parameterize(*testing.product_dict(
[
{'shape': (5, 6, 2)},
{'shape': (8, 9, 4, 5)},
{'shape': (1, 0, 5)},
], [
{'dtype': numpy.float16},
{'dtype': numpy.float32},
{'dtype': numpy.float64},
], [
{'grad_outputs': (True, True)},
{'grad_outputs': (True, False)},
{'grad_outputs': (False, True)},
], [
{'flat': True},
{'flat': False},
]
))
@testing.fix_random()
@backend.inject_backend_tests(
None,
# ChainerX tests
testing.product({
'use_chainerx': [True],
'chainerx_device': ['native:0', 'cuda:0'],
@testing.parameterize(*testing.product_dict(
[
{
'in_shape': (3, 24, 16),
'size': 8,
'fit_short': True,
'out_shape': (3, 12, 8)
},
{
'in_shape': (3, 16, 24),
'size': 8,
'fit_short': True,
'out_shape': (3, 8, 12)
},
{
'in_shape': (3, 16, 24),
'size': 24,
'fit_short': True,
'out_shape': (3, 24, 36)
},
{
'in_shape': (3, 24, 16),
'size': 36,
'fit_short': False,
'out_shape': (3, 36, 24)
},
{
'in_shape': (3, 16, 24),
'size': 36,
'fit_short': False,
'out_shape': (3, 24, 36)
},
{
'in_shape': (3, 24, 12),
'size': 12,
'fit_short': False,
'out_shape': (3, 12, 6)
},
# grayscale
{
'in_shape': (1, 16, 24),
'size': 8,
'fit_short': True,
'out_shape': (1, 8, 12)
},
{
'in_shape': (1, 16, 24),
'size': 36,
'fit_short': False,
'out_shape': (1, 24, 36)
},
],
[
{
'interpolation': PIL.Image.NEAREST
},
{
'interpolation': PIL.Image.BILINEAR
},
{
'interpolation': PIL.Image.BICUBIC
},
{
'interpolation': PIL.Image.LANCZOS
},
]))
from chainer import testing
from chainer.testing import attr
from chainer import utils
@testing.parameterize(*testing.product_dict(
[{'dtype': numpy.float16,
'forward_options': {'rtol': 5e-3, 'atol': 5e-3},
'backward_options': {'eps': 1e-1, 'rtol': 1e-1, 'atol': 1e-1},
'double_backward_options': {'eps': 1e-1, 'rtol': 1e-1, 'atol': 1e-1}},
{'dtype': numpy.float32,
'forward_options': {},
'backward_options': {'eps': 1e-3, 'rtol': 1e-2, 'atol': 1e-2},
'double_backward_options': {'eps': 1e-3, 'rtol': 1e-2, 'atol': 1e-2}},
{'dtype': numpy.float64,
'forward_options': {},
'backward_options': {'eps': 1e-3, 'rtol': 1e-2, 'atol': 1e-2},
'double_backward_options': {'eps': 1e-3, 'rtol': 1e-2, 'atol': 1e-2}},
],
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__()
})
alpha_params = testing.product({
# writing alpha image with jpeg encoding didn't work
'format': ['png'],
'color': [True],
'alpha': ['ignore', 'blend_with_white', 'blend_with_black']
})
params = testing.product_dict(
params, no_color_params + no_alpha_params + alpha_params)
return params
@testing.parameterize(*testing.product_dict(_create_parameters(),
[{
'backend': 'cv2'
}, {
'backend': 'PIL'
}, {
'backend': None
}]))
class TestReadImage(unittest.TestCase):
def setUp(self):
if self.file_obj:
self.f = tempfile.TemporaryFile()
self.file = self.f
format = self.format
else:
if self.format == 'jpeg':
suffix = '.jpg'
else:
suffix = '.' + self.format
self.f = tempfile.NamedTemporaryFile(suffix=suffix, delete=False)
@condition.retry(10)
def test_cpu(self):
self.check_backward(self.x, self.gy)
@attr.gpu
@condition.retry(10)
def test_gpu(self):
self.check_backward(cuda.to_gpu(self.x), cuda.to_gpu(self.gy))
@testing.parameterize(*testing.product_dict(
[
{'left_const': False, 'right_const': False},
{'left_const': True, 'right_const': False},
{'left_const': False, 'right_const': True},
], [
{'dtype': numpy.float16},
{'dtype': numpy.float32},
{'dtype': numpy.float64},
]
))
class TestMatMulVarVar(unittest.TestCase):
def setUp(self):
self.x = numpy.random.uniform(-1, 1, (3, 2)).astype(self.dtype)
self.y = numpy.random.uniform(-1, 1, (2, 4)).astype(self.dtype)
self.gz = numpy.random.uniform(-1, 1, (3, 4)).astype(self.dtype)
def check_forward(self, x_data, y_data):
if self.left_const:
x = x_data
import numpy
from chainer import functions
from chainer import testing
@testing.parameterize(*testing.product_dict(
[
{'shape': (2, 4, 6), 'args': (1, 2, 0)},
{'shape': (2, 4, 6), 'args': (-1, 2, 0)},
{'shape': (2, 4, 6), 'args': (0, -1, -2)},
{'shape': (2, 4, 6), 'args': (0, -1, 1)},
],
[
{'dtype': numpy.float16},
{'dtype': numpy.float32},
{'dtype': numpy.float64},
],
))
@testing.inject_backend_tests(
None,
# CPU tests
testing.product({
'use_ideep': ['never', 'always'],
})
# GPU tests
+ [{'use_cuda': True}]
# ChainerX tests
+ testing.product({
'use_chainerx': [True],
'chainerx_device': ['native:0', 'cuda:0', 'cuda:1'],
def test_pos_neg_duplicate_axis(self):
with self.assertRaises(ValueError):
self.x.min(axis=(1, -2))
@testing.parameterize(*testing.product_dict(
[
{'function_name': 'argmax', 'function_class': functions.ArgMax},
{'function_name': 'argmin', 'function_class': functions.ArgMin},
],
[
{'axis': None},
{'axis': 0},
{'axis': 1},
{'axis': 2},
{'axis': -1},
{'axis': -2},
{'axis': -3},
],
[
{'dtype': numpy.float16},
{'dtype': numpy.float32},
{'dtype': numpy.float64},
]
))
class TestArgMinMax(unittest.TestCase):
def setUp(self):
self.function = getattr(functions, self.function_name)
self.expect = getattr(numpy, self.function_name)
@testing.parameterize(*testing.product_dict(
[
{
'shape': (2, 4, 6),
'args': (1, 2, 0)
},
{
'shape': (2, 4, 6),
'args': (-1, 2, 0)
},
{
'shape': (2, 4, 6),
'args': (0, -1, -2)
},
{
'shape': (2, 4, 6),
'args': (0, -1, 1)
},
],
[
{
'dtype': numpy.float16
},
{
'dtype': numpy.float32
},
{
'dtype': numpy.float64
},
],
))
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
from chainer.utils import type_check
@testing.parameterize(*testing.product_dict(
[
{'pyramid_height': 3, 'output_dim': 63, 'n': 2, 'c': 3, 'h': 9, 'w': 8}
],
[
{'pooling': 'max'},
{'pooling_class': functions.MaxPooling2D} # Test deprecated argument
],
[
{'dtype': numpy.float16},
{'dtype': numpy.float32},
{'dtype': numpy.float64}
]
))
class TestSpatialPyramidPooling2D(unittest.TestCase):
def setUp(self):
# Spacial pyramid pooling uses max pooling in its implementation.
# To avoid instability of numerical gradient, use enough different
# values.
shape = (self.n, self.c, self.h, self.w)
size = numpy.prod(shape)
self.x = numpy.arange(size, dtype=self.dtype).reshape(shape)
@testing.parameterize(*testing.product_dict([
{
'left_const': False,
'right_const': False
},
{
'left_const': True,
'right_const': False
},
{
'left_const': False,
'right_const': True
},
], [
{
'dtype': numpy.float16
},
{
'dtype': numpy.float32
},
{
'dtype': numpy.float64
},
], [
{
'x_shape': (3, 2),
'y_shape': (2, 4),
'z_shape': (3, 4)
},
{
'x_shape': (2, 3, 2),
'y_shape': (2, 2, 4),
'z_shape': (2, 3, 4)
},
{
'x_shape': (2, 1, 3, 4),
'y_shape': (2, 4, 2),
'z_shape': (2, 2, 3, 2)
},
{
'x_shape': (5, 3, 2),
'y_shape': (2, ),
'z_shape': (5, 3)
},
{
'x_shape': (2, ),
'y_shape': (5, 2, 4),
'z_shape': (5, 4)
},
{
'x_shape': (2, 3, 2),
'y_shape': (2, 4),
'z_shape': (2, 3, 4)
},
{
'x_shape': (3, ),
'y_shape': (3, ),
'z_shape': ()
},
]))
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_dict(
[
{'x_shape': (4, 3, 2), 'beta_shape': (3,),
'extended_beta_shape': (1, 3, 1)},
{'x_shape': (4, 3, 2), 'beta_shape': (3, 2),
'extended_beta_shape': (1, 3, 2)},
], [
{'dtype': numpy.float16},
{'dtype': numpy.float32},
{'dtype': numpy.float64},
]
))
@testing.fix_random()
class TestSwish(unittest.TestCase):
def setUp(self):
self.x = numpy.random.uniform(-1, 1, self.x_shape).astype(self.dtype)
self.beta = numpy.random.uniform(-1, 1, self.beta_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.ggb = numpy.random.uniform(-1, 1, self.beta_shape)\
@testing.parameterize(*testing.product_dict([
{
'shape': (3, 4)
},
{
'shape': ()
},
], [
{
'in_type': numpy.bool_
},
{
'in_type': numpy.uint8
},
{
'in_type': numpy.uint64
},
{
'in_type': numpy.int8
},
{
'in_type': numpy.int64
},
{
'in_type': numpy.float16
},
{
'in_type': numpy.float32
},
{
'in_type': numpy.float64
},
], [
{
'out_type': numpy.bool_
},
{
'out_type': numpy.uint8
},
{
'out_type': numpy.uint64
},
{
'out_type': numpy.int8
},
{
'out_type': numpy.int64
},
{
'out_type': numpy.float16
},
{
'out_type': numpy.float32
},
{
'out_type': numpy.float64
},
]))
@testing.parameterize(*testing.product_dict(
[
{'in_shape': (3, 24, 16), 'size': 8,
'fit_short': True, 'out_shape': (3, 12, 8)},
{'in_shape': (3, 16, 24), 'size': 8,
'fit_short': True, 'out_shape': (3, 8, 12)},
{'in_shape': (3, 16, 24), 'size': 24,
'fit_short': True, 'out_shape': (3, 24, 36)},
{'in_shape': (3, 24, 16), 'size': 36,
'fit_short': False, 'out_shape': (3, 36, 24)},
{'in_shape': (3, 16, 24), 'size': 36,
'fit_short': False, 'out_shape': (3, 24, 36)},
{'in_shape': (3, 24, 12), 'size': 12,
'fit_short': False, 'out_shape': (3, 12, 6)},
# grayscale
{'in_shape': (1, 16, 24), 'size': 8,
'fit_short': True, 'out_shape': (1, 8, 12)},
{'in_shape': (1, 16, 24), 'size': 36,
'fit_short': False, 'out_shape': (1, 24, 36)},
],
[
{'interpolation': PIL.Image.NEAREST},
{'interpolation': PIL.Image.BILINEAR},
{'interpolation': PIL.Image.BICUBIC},
{'interpolation': PIL.Image.LANCZOS},
]
))
class TestScale(unittest.TestCase):
return 0.0
else:
return float(count) / total
@testing.parameterize(
*testing.product_dict(
[{'x_shape': (10, 3), 't_shape': (10,)},
{'x_shape': (10, 3, 1), 't_shape': (10,)},
{'x_shape': (10, 3, 1, 1), 't_shape': (10,)},
{'x_shape': (10, 3, 5), 't_shape': (10, 5)},
{'x_shape': (10, 3, 5, 4), 't_shape': (10, 5, 4)},
{'x_shape': (10, 3, 5, 4, 1), 't_shape': (10, 5, 4)},
{'x_shape': (10, 3, 5, 4, 1, 1), 't_shape': (10, 5, 4)}],
[{'ignore_label': None, 't_data': 'randint'},
{'ignore_label': 0, 't_data': 'randint'},
{'ignore_label': 0, 't_data': 'zero'}],
[{'dtype': numpy.float16},
{'dtype': numpy.float32},
{'dtype': numpy.float64}],
[{'label_dtype': numpy.int8},
{'label_dtype': numpy.int16},
{'label_dtype': numpy.int32},
{'label_dtype': numpy.int64}]
)
)
@testing.fix_random()
@testing.inject_backend_tests(
None,
# CPU tests
[
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_dict(
[
{'shape': (3, 4)},
{'shape': ()},
],
[
{'in_type': numpy.float16},
{'in_type': numpy.float32},
{'in_type': numpy.float64},
],
[
{'out_type': numpy.float16},
{'out_type': numpy.float32},
{'out_type': numpy.float64},
]
))
class TestCast(unittest.TestCase):
def setUp(self):
self.x = numpy.random.uniform(-1, 1, self.shape).astype(self.in_type)
self.g = numpy.random.uniform(-1, 1, self.shape).astype(self.out_type)
def check_forward(self, x_data):
x = chainer.Variable(x_data)
from chainer import testing
from chainer.testing import attr
from chainer.testing import condition
@testing.parameterize(*testing.product_dict([{
'x_data': [0, 1, 0],
'ignore_label': None
}, {
'x_data': [[0, 1, 0], [1, 0, 1]],
'ignore_label': None
}, {
'x_data': [0, 1, -1],
'ignore_label': -1
}, {
'x_data': [[0, 1, -1], [-1, 0, 1]],
'ignore_label': -1
}], [{
'label_dtype': numpy.int8
}, {
'label_dtype': numpy.int16
}, {
'label_dtype': numpy.int32
}, {
'label_dtype': numpy.int64
}]))
class TestEmbedID(unittest.TestCase):
def setUp(self):
self.x = numpy.array(self.x_data, dtype=self.label_dtype)
self.W = numpy.random.uniform(-1, 1, (3, 2)).astype('f')
y_shape = self.x.shape + (2, )
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_dict(
[
{'lengths': [3, 3], 'batches': [2, 2, 2]},
{'lengths': [3, 2, 1], 'batches': [3, 2, 1]},
{'lengths': [3, 1, 1], 'batches': [3, 1, 1]},
{'lengths': [1, 1], 'batches': [2]},
],
[
{'reduce': 'mean'},
{'reduce': 'no'},
]
))
class TestCRF1d(unittest.TestCase):
n_label = 3
def setUp(self):
self.cost = numpy.random.uniform(
-1, 1, (self.n_label, self.n_label)).astype(numpy.float32)
self.xs = [numpy.random.uniform(
-1, 1, (b, 3)).astype(numpy.float32) for b in self.batches]
self.ys = [
numpy.random.randint(
@testing.parameterize(*testing.product_dict([
{
'function_name': 'argmax'
},
{
'function_name': 'argmin'
},
], [
{
'axis': None
},
{
'axis': 0
},
{
'axis': 1
},
{
'axis': 2
},
{
'axis': -1
},
{
'axis': -2
},
{
'axis': -3
},
], [
{
'dtype': numpy.float16
},
{
'dtype': numpy.float32
},
{
'dtype': numpy.float64
},
]))
import numpy
import chainer
from chainer import cuda
from chainer.functions.connection import embed_id
from chainer import gradient_check
from chainer import testing
from chainer.testing import attr
@testing.parameterize(*testing.product_dict(
[{'x_data': [0, 1, 0], 'ignore_label': None},
{'x_data': [[0, 1, 0], [1, 0, 1]], 'ignore_label': None},
{'x_data': [0, 1, -1], 'ignore_label': -1},
{'x_data': [[0, 1, -1], [-1, 0, 1]], 'ignore_label': -1}],
[{'label_dtype': numpy.int8},
{'label_dtype': numpy.int16},
{'label_dtype': numpy.int32},
{'label_dtype': numpy.int64}]
))
class TestEmbedID(unittest.TestCase):
def setUp(self):
self.x = numpy.array(self.x_data, dtype=self.label_dtype)
self.W = numpy.random.uniform(-1, 1, (3, 2)).astype('f')
y_shape = self.x.shape + (2,)
self.gy = numpy.random.uniform(-1, 1, y_shape).astype(numpy.float32)
self.ggW = numpy.random.uniform(-1, 1, (3, 2)).astype('f')
self.check_backward_options = {'atol': 1e-2, 'rtol': 1e-2}
self.check_double_backward_options = {'atol': 1e-2, 'rtol': 1e-2}
@testing.parameterize(*testing.product_dict(
[
{
'shape': (2, 7, 3),
'axis':
1,
'ys_section': [2, 5],
'slices': [[slice(None), slice(None, 2)], [
slice(None), slice(2, 5)
], [slice(None), slice(5, None)]]
},
{
'shape': (7, 3),
'axis': 0,
'ys_section': [2, 5],
'slices': [slice(None, 2),
slice(2, 5),
slice(5, None)]
},
{
'shape': (2, 9, 3),
'axis':
1,
'ys_section':
3,
'slices': [[slice(None), slice(None, 3)], [
slice(None), slice(3, 6)
], [slice(None), slice(6, None)]]
},
{
'shape': (2, 6, 3),
'axis':
1,
'ys_section':
3,
'slices': [[slice(None), slice(None, 2)], [
slice(None), slice(2, 4)
], [slice(None), slice(4, None)]]
},
{
'shape': (2, ),
'axis': 0,
'ys_section': [1],
'slices': [slice(None, 1), slice(1, None)]
},
{
'shape': (2, ),
'axis': 0,
'ys_section': [],
'slices': [slice(None, None)]
},
{
'shape': (2, 7, 3),
'axis':
1,
'ys_section': [2, 5],
'slices': [[slice(None), slice(None, 2)], [
slice(None), slice(2, 5)
], [slice(None), slice(5, None)]]
},
{
'shape': (2, 7, 3),
'axis':
1,
'ys_section': [2, 5],
'slices': [[slice(None), slice(None, 2)], [
slice(None), slice(2, 5)
], [slice(None), slice(5, None)]]
},
],
[
{
'dtype': numpy.float16
},
{
'dtype': numpy.float32
},
{
'dtype': numpy.float64
},
],
))
from chainer import testing
from chainer.testing import attr
from chainer.testing import condition
from chainer.utils import type_check
@testing.parameterize(*testing.product_dict(
[
{'in_shapes': [(3, 1, 5), (1, 2, 5)], 'out_shape': (3, 2, 5)},
{'in_shapes': [(3, 2, 5), (5,)], 'out_shape': (3, 2, 5)},
{'in_shapes': [(3, 2, 5), ()], 'out_shape': (3, 2, 5)},
{'in_shapes': [(3, 2, 5), (3, 2, 5)], 'out_shape': (3, 2, 5)},
{'in_shapes': [(), ()], 'out_shape': ()},
{'in_shapes': [(1, 1, 1), (1,)], 'out_shape': (1, 1, 1)},
{'in_shapes': [(1, 1, 1), ()], 'out_shape': (1, 1, 1)},
{'in_shapes': [(3, 2, 5)], 'out_shape': (3, 2, 5)},
{'in_shapes': [(3, 1, 5), (1, 2, 5), (3, 2, 1)],
'out_shape': (3, 2, 5)},
],
[
{'dtype': numpy.float16},
{'dtype': numpy.float32},
{'dtype': numpy.float64},
],
))
class TestBroadcast(unittest.TestCase):
def setUp(self):
uniform = numpy.random.uniform
self.data = [uniform(0, 1, shape).astype(self.dtype)
for shape in self.in_shapes]
@testing.parameterize(*testing.product_dict(
[
{'shape': (2, 7, 3), 'axis': 1, 'ys_section': [2, 5],
'slices': [
(slice(None), slice(None, 2)),
(slice(None), slice(2, 5)),
(slice(None), slice(5, None))]},
{'shape': (7, 3), 'axis': 0, 'ys_section': [2, 5],
'slices': [slice(None, 2), slice(2, 5), slice(5, None)]},
{'shape': (7, 0), 'axis': 0, 'ys_section': [2, 5],
'slices': [slice(None, 2), slice(2, 5), slice(5, None)]},
{'shape': (2, 9, 3), 'axis': 1, 'ys_section': 3,
'slices': [
(slice(None), slice(None, 3)),
(slice(None), slice(3, 6)),
(slice(None), slice(6, None))]},
{'shape': (2, 6, 3), 'axis': 1, 'ys_section': 3,
'slices': [
(slice(None), slice(None, 2)),
(slice(None), slice(2, 4)),
(slice(None), slice(4, None))]},
{'shape': (2,), 'axis': 0, 'ys_section': [1],
'slices': [slice(None, 1), slice(1, None)]},
{'shape': (2,), 'axis': 0, 'ys_section': [],
'slices': [slice(None, None)]},
{'shape': (2, 7, 3), 'axis': 1, 'ys_section': [2, 5],
'slices': [
(slice(None), slice(None, 2)),
(slice(None), slice(2, 5)),
(slice(None), slice(5, None))]},
{'shape': (2, 7, 3), 'axis': 1, 'ys_section': [0],
'slices': [
(slice(None), slice(None, 0)),
(slice(None), slice(0, 7))]
},
{'shape': (2, 7, 3), 'axis': 1, 'ys_section': [7],
'slices': [
(slice(None), slice(None, 7)),
(slice(None), slice(7, 7))]
},
{'shape': (2, 7, 3, 2), 'axis': 1, 'ys_section': [2, 5],
'slices': [
(slice(None), slice(None, 2)),
(slice(None), slice(2, 5)),
(slice(None), slice(5, None))]},
{'shape': (2, 7, 3, 2), 'axis': 1, 'ys_section': [0],
'slices': [
(slice(None), slice(None, 0)),
(slice(None), slice(0, 7))]
},
{'shape': (10, 4, 3, 2), 'axis': 0, 'ys_section': 1,
'slices': [slice(None, None)]
},
{'shape': (10, 4, 3, 2), 'axis': 0, 'ys_section': 2,
'slices': [slice(None, 5), slice(5, None)]
},
{'shape': (10, 4, 3, 2), 'axis': 0, 'ys_section': [],
'slices': [slice(None, None)]
},
{'shape': (10, 4, 3, 2), 'axis': 0, 'ys_section': [0, 5],
'slices': [slice(0, 0), slice(0, 5), slice(5, None)]
},
{'shape': (10, 4, 3, 2), 'axis': 0, 'ys_section': [0, 0, 5],
'slices': [slice(0, 0), slice(0, 0), slice(None, 5), slice(5, None)]
},
{'shape': (10, 4, 3, 2), 'axis': 0, 'ys_section': [2, 3, 5],
'slices': [slice(None, 2), slice(2, 3), slice(3, 5), slice(5, None)]
},
{'shape': (10, 4, 3, 2), 'axis': 0,
'ys_section': numpy.asarray([2, 3, 5]),
'slices': [slice(None, 2), slice(2, 3), slice(3, 5), slice(5, None)]
},
{'shape': (10, 4, 3, 2), 'axis': 0, 'ys_section': [2, 3, 3, 5],
'slices': [slice(None, 2), slice(2, 3), slice(3, 3), slice(3, 5),
slice(5, None)]
},
{'shape': (5, 5, 3, 8), 'axis': 3, 'ys_section': 2,
'slices': [
(slice(None, None), slice(None, None), slice(None, None),
slice(None, 4)),
(slice(None, None), slice(None, None), slice(None, None),
slice(4, None))]
},
{'shape': (5, 8, 3, 2), 'axis': -3, 'ys_section': 2,
'slices': [(slice(None, None), slice(None, 4)),
(slice(None, None), slice(4, None))]
},
{'shape': (5, 8, 3, 2), 'axis': 1, 'ys_section': 2,
'slices': [(slice(None, None), slice(None, 4)),
(slice(None, None), slice(4, None))]
},
{'shape': (5, 4, 3, 4), 'axis': -1, 'ys_section': 2,
'slices': [
(slice(None, None), slice(None, None), slice(None, None),
slice(None, 2)),
(slice(None, None), slice(None, None), slice(None, None),
slice(2, None))]
},
{'shape': (10, 4, 3, 2), 'axis': 0, 'ys_section': numpy.array([]),
'slices': [slice(None, None)]
},
],
[
{'dtype': numpy.float16},
{'dtype': numpy.float32},
{'dtype': numpy.float64},
],
))
import chainer
from chainer import cuda
from chainer import functions
from chainer import testing
from chainer.testing import attr
@testing.parameterize(*testing.product_dict(
[
{'in_shape': (3, 2), 'out_shape': (1, 3, 2), 'axis': 0},
{'in_shape': (3, 2), 'out_shape': (3, 1, 2), 'axis': 1},
{'in_shape': (3, 2), 'out_shape': (3, 2, 1), 'axis': 2},
{'in_shape': (3, 2), 'out_shape': (3, 2, 1), 'axis': -1},
{'in_shape': (3, 2), 'out_shape': (3, 1, 2), 'axis': -2},
{'in_shape': (3, 2), 'out_shape': (1, 3, 2), 'axis': -3},
{'in_shape': (3, 2), 'out_shape': (1, 3, 2), 'axis': 0},
{'in_shape': (3, 2), 'out_shape': (1, 3, 2), 'axis': 0},
],
[
{'dtype': numpy.float16},
{'dtype': numpy.float32},
{'dtype': numpy.float64},
],
))
class TestExpandDims(unittest.TestCase):
def setUp(self):
self.x = numpy.random.uniform(-1, 1, self.in_shape).astype(self.dtype)
def check_forward(self, x_data):
x = chainer.Variable(x_data)
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_dict(
[
{'in_shape': (10, 5), 'out_shape': (10,)},
{'in_shape': (0, 5), 'out_shape': (0,)},
{'in_shape': (1, 33), 'out_shape': (1,)},
{'in_shape': (10, 5), 'out_shape': (10,)},
{'in_shape': (10, 5), 'out_shape': (10,)},
],
[
{'dtype': numpy.float16},
{'dtype': numpy.float32},
{'dtype': numpy.float64},
],
))
class TestSelectItem(unittest.TestCase):
def setUp(self):
self.x_data = numpy.random.uniform(
-1, 1, self.in_shape).astype(self.dtype)
self.t_data = numpy.random.randint(
0, 2, self.out_shape).astype(numpy.int32)
self.gy_data = numpy.random.uniform(
-1, 1, self.out_shape).astype(self.dtype)
self.check_double_backward(self.x, self.gy, self.ggx)
@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))
@testing.parameterize(*testing.product_dict(
[
{'left_const': False, 'right_const': False},
{'left_const': True, 'right_const': False},
{'left_const': False, 'right_const': True},
], [
{'dtype': numpy.float16},
{'dtype': numpy.float32},
{'dtype': numpy.float64},
], [
{'x_shape': (3, 2), 'y_shape': (2, 4), 'z_shape': (3, 4)},
{'x_shape': (2, 3, 2), 'y_shape': (2, 2, 4), 'z_shape': (2, 3, 4)},
{'x_shape': (3,), 'y_shape': (3,), 'z_shape': ()},
]
))
@unittest.skipUnless(sys.version_info >= (3, 5),
'Only for Python3.5 or higher')
class TestMatMulVarVar(unittest.TestCase):
def setUp(self):
self.x = numpy.random.uniform(-1, 1, self.x_shape).astype(self.dtype)
self.y = numpy.random.uniform(-1, 1, self.y_shape).astype(self.dtype)
self.gz = numpy.random.uniform(-1, 1, self.z_shape).astype(self.dtype)
def _pair(x):
if hasattr(x, '__getitem__'):
return x
return x, x
@testing.parameterize(*testing.product_dict([{
'params': (1, 1, 1, 1, 1, 1, 1, 1)
}, {
'params': (2, 2, 2, 2, 2, 2, 2, 2)
}, {
'params': (1, 2, 2, 1, 1, 2, 1, 1)
}, {
'params': (1, 2, 3, 4, 1, 2, 1, 1)
}, {
'params': (1, 2, 3, 4, 4, 5, 2, 3)
}, {
'params': (3, 3, 2, 2, 1, 1, 1, 1)
}], [{
'dtype': numpy.float16
}, {
'dtype': numpy.float32
}, {
'dtype': numpy.float64
}]))
class TestIm2ColForward(unittest.TestCase):
in_shape = (2, 3, 8, 6)
def setUp(self):
self.x = numpy.random.uniform(size=self.in_shape).astype(self.dtype)
@attr.gpu
def test_double_backward_gpu_no_cudnn(self):
self.check_double_backward(
cuda.to_gpu(self.x), cuda.to_gpu(self.t),
cuda.to_gpu(self.gy), cuda.to_gpu(self.ggx),
None if not self.weight_apply else cuda.to_gpu(self.class_weight),
'never')
@testing.parameterize(*testing.product_dict(
[
{'t_value': -2, 'valid': False},
{'t_value': 3, 'valid': False},
{'t_value': -1, 'valid': True} # -1 is ignore_label
],
[
{'enable_double_backprop': True},
{'enable_double_backprop': False}
]
))
class TestSoftmaxCrossEntropyValueCheck(unittest.TestCase):
def setUp(self):
self.x = numpy.random.uniform(-1, 1, (2, 2)).astype(numpy.float32)
# `0` is required to avoid NaN
self.t = numpy.array([self.t_value, 0], dtype=numpy.int32)
self.original_debug = chainer.is_debug()
chainer.set_debug(True)
def tearDown(self):
@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],
}),
))
from chainer import backend
from chainer.backends import cuda
from chainer import initializers
from chainer import testing
from chainer.testing import attr
from chainer.testing import condition
@testing.parameterize(*testing.product_dict(
[
{'shape': (), 'dim_in': 1, 'dim_out': 1},
{'shape': (1,), 'dim_in': 1, 'dim_out': 1},
{'shape': (3, 4), 'dim_in': 4, 'dim_out': 3},
{'shape': (3, 4, 5), 'dim_in': 20, 'dim_out': 3}
],
[
{'scale': 2., 'dtype': numpy.float16}
] + testing.product({
'scale': [None, 7.3],
'dtype': [numpy.float32, numpy.float64],
})
))
class OrthogonalBase(unittest.TestCase):
target = initializers.Orthogonal
def setUp(self):
kwargs = {}
if self.scale is not None:
kwargs['scale'] = self.scale
self.target_kwargs = kwargs
loss_expect[loss_idx] = -(xi - log_z)[ti]
else:
loss_expect[loss_idx] = -(xi - log_z)[ti] * class_weight[ti]
return numpy.asarray(loss_expect, dtype=x.dtype)
@testing.parameterize(*testing.product_dict(
[
{
't_value': -2,
'valid': False
},
{
't_value': 3,
'valid': False
},
{
't_value': -1,
'valid': True
} # -1 is ignore_label
],
[{
'enable_double_backprop': True
}, {
'enable_double_backprop': False
}]))
class TestSoftmaxCrossEntropyValueCheck(unittest.TestCase):
def setUp(self):
self.x = numpy.random.uniform(-1, 1, (2, 2)).astype(numpy.float32)
# `0` is required to avoid NaN
self.t = numpy.array([self.t_value, 0], dtype=numpy.int32)
self.original_debug = chainer.is_debug()
{'use_chainerx': True, 'chainerx_device': 'native:0'},
{'use_chainerx': True, 'chainerx_device': 'cuda:0'},
{'use_chainerx': True, 'chainerx_device': 'cuda:1'},
])
@testing.inject_backend_tests(None, _backend_params)
@testing.parameterize(*testing.product_dict(
[{'dtype': numpy.float16},
{'dtype': numpy.float32},
{'dtype': numpy.float64},
],
[{'axes': [1, 2], 'offsets': 0},
{'axes': [1, 2], 'offsets': [0, 1, 1]},
{'axes': 1, 'offsets': 1},
{'axes': 1, 'offsets': [0, 1, 1]},
{'axes': [], 'offsets': 0, 'new_axes': 0},
{'axes': [], 'offsets': 0, 'new_axes': 2},
{'axes': [], 'offsets': 0, 'new_axes': 3},
{'slices': (1, -1, 0)},
{'slices': (1, -1)},
{'slices': (1, Ellipsis, -1)},
{'slices': (1, None, Ellipsis, None, -1)},
]
))
class TestGetItem(testing.FunctionTestCase):
def setUp(self):
shape = (4, 2, 1)
if not hasattr(self, 'slices'):
axes = self.axes
if running_var is not None:
running_var *= decay
running_var += (1 - decay) * adjust * var
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({
'xdtype': [numpy.float16, numpy.float32],
'dtype': [numpy.float16, numpy.float32],
'eps': [2e-5, 5e-1],
'c_contiguous': [True, False],
'running_statistics': [True, False],
}),
) + testing.product({
'param_shape': [(3,)],
'ndim': [1],
'eps': [2e-5, 5e-1],
'xdtype': [numpy.float16, numpy.float32, numpy.float64],
'dtype': [numpy.float16, numpy.float32, numpy.float64],
'c_contiguous': [True, False],
'running_statistics': [True, False],
from chainer import gradient_check
from chainer import testing
from chainer.testing import attr
from chainer.testing import condition
from chainer.utils import type_check
@testing.parameterize(*testing.product_dict(
[
{'shape': (1,), 'axis': 0},
{'shape': (2, 3, 4), 'axis': 0},
{'shape': (2, 3, 4), 'axis': 1},
{'shape': (2, 3, 4), 'axis': 2},
{'shape': (2, 3, 4), 'axis': -3},
{'shape': (2, 3, 4), 'axis': -2},
{'shape': (2, 3, 4), 'axis': -1},
{'shape': (2, 3, 4), 'axis': None},
],
[
{'dtype': numpy.float16},
{'dtype': numpy.float32},
{'dtype': numpy.float64},
],
))
class TestCumsum(unittest.TestCase):
def setUp(self):
self.x = numpy.random.uniform(-1, 1, self.shape).astype(self.dtype)
self.gy = numpy.random.uniform(-1, 1, self.shape).astype(self.dtype)
self.ggx = numpy.random.uniform(-1, 1, self.shape).astype(self.dtype)
if self.axis is None:
from chainer import gradient_check
from chainer import testing
from chainer.testing import attr
from chainer.testing import condition
from chainer.utils import type_check
@testing.parameterize(*testing.product_dict(
[
{'shape': (1,), 'axis': 0},
{'shape': (2, 3, 4), 'axis': 0},
{'shape': (2, 3, 4), 'axis': 1},
{'shape': (2, 3, 4), 'axis': 2},
{'shape': (2, 3, 4), 'axis': -3},
{'shape': (2, 3, 4), 'axis': -2},
{'shape': (2, 3, 4), 'axis': -1},
{'shape': (2, 3, 4), 'axis': None},
],
[
{'dtype': numpy.float16},
{'dtype': numpy.float32},
{'dtype': numpy.float64},
],
))
class TestCumsum(unittest.TestCase):
def setUp(self):
self.x = numpy.random.uniform(-1, 1, self.shape).astype(self.dtype)
self.gy = numpy.random.uniform(-1, 1, self.shape).astype(self.dtype)
self.ggx = numpy.random.uniform(-1, 1, self.shape).astype(self.dtype)
if self.axis is None:
import numpy
from chainer import functions
from chainer import testing
@testing.parameterize(*testing.product_dict(
[
{'shape': (), 'pad_width': 1, 'mode': 'constant'},
{'shape': (2, 3), 'pad_width': 0, 'mode': 'constant'},
{'shape': (2, 3), 'pad_width': 1, 'mode': 'constant'},
{'shape': (2, 3), 'pad_width': (1, 2), 'mode': 'constant'},
{'shape': (2, 3), 'pad_width': ((1, 2), (3, 4)), 'mode': 'constant'},
{'shape': (2, 3, 2), 'pad_width': ((2, 5), (1, 2), (0, 7)),
'mode': 'constant'},
{'shape': (1, 3, 5, 2), 'pad_width': 2, 'mode': 'constant'}
],
[
{'dtype': numpy.float16},
{'dtype': numpy.float32},
{'dtype': numpy.float64}
]
))
@testing.inject_backend_tests(
None,
# CPU tests
[
{},
]
# GPU tests
+ testing.product({
@testing.parameterize(*testing.product_dict(
[{
'shape': (),
'pad_width': 1,
'mode': 'constant'
}, {
'shape': (2, 3),
'pad_width': 0,
'mode': 'constant'
}, {
'shape': (2, 3),
'pad_width': 1,
'mode': 'constant'
}, {
'shape': (2, 3),
'pad_width': (1, 2),
'mode': 'constant'
}, {
'shape': (2, 3),
'pad_width': ((1, 2), (3, 4)),
'mode': 'constant'
}, {
'shape': (2, 3, 2),
'pad_width': ((2, 5), (1, 2), (0, 7)),
'mode': 'constant'
}, {
'shape': (1, 3, 5, 2),
'pad_width': 2,
'mode': 'constant'
}], [{
'dtype': numpy.float16
}, {
'dtype': numpy.float32
}, {
'dtype': numpy.float64
}]))
lower = 1
else:
lower = -1
t = numpy.random.randint(lower, label_num, shape)
return t.astype(dtype)
@testing.parameterize(*(
testing.product_dict(
[{'y_shape': (100, 3), 't_shape': (100,)},
{'y_shape': (100, 3, 5), 't_shape': (100, 5)}],
[{'dtype': numpy.float32}],
[{'beta': 1.0},
{'beta': 2.0}],
[{'label_num': 3},
{'label_num': None}],
[{'ignore_label': -1},
{'ignore_label': 0}],
[{'has_ignore_label': True},
{'has_ignore_label': False}],
[{'label_dtype': numpy.int32}]
) + testing.product_dict(
[{'y_shape': (100, 3), 't_shape': (100,)}],
[{'dtype': numpy.float16},
{'dtype': numpy.float32},
{'dtype': numpy.float64}],
[{'beta': 1.0}],
[{'label_num': 3}],
[{'ignore_label': 0}],
[{'has_ignore_label': True}],
[{'label_dtype': numpy.int8},
from chainer import testing
from chainer.testing import attr
import numpy
@testing.parameterize(*(testing.product_dict(
[{
'target': initializers.Normal,
'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):
SS_tot_iszero = SS_tot == 0
SS_tot[SS_tot_iszero] = 1
return numpy.where(SS_tot_iszero, 0.0, 1 - SS_res / SS_tot)
else:
return 1 - SS_res / SS_tot
@testing.parameterize(
*testing.product_dict(
[{'x_shape': (10,), 't_shape': (10,)},
{'x_shape': (10, 1), 't_shape': (10, 1)},
{'x_shape': (10, 5), 't_shape': (10, 5)},
{'x_shape': (10, 5, 4), 't_shape': (10, 5, 4)}],
[{'t_input': 'random'}, {'t_input': 'zero'}],
[{'multioutput': 'uniform_average'},
{'multioutput': 'raw_values'}],
[{'sample_weight': None}],
[{'dtype': numpy.float16},
{'dtype': numpy.float32},
{'dtype': numpy.float64}]
)
)
@testing.fix_random()
@testing.inject_backend_tests(
None,
# CPU tests
[
{},
]
# GPU tests
@testing.parameterize(*testing.product_dict(
[
{
'axis': None,
'out_shape': (3, )
},
{
'axis': 1,
'out_shape': (1, 3, 1)
},
{
'axis': -3,
'out_shape': (1, 3, 1)
},
{
'axis': (0, 1, 3),
'out_shape': (3, )
},
{
'axis': (3, 1, 0),
'out_shape': (3, )
},
{
'axis': (-4, -3, -1),
'out_shape': (3, )
},
{
'axis': (-1, -3, -4),
'out_shape': (3, )
},
],
[
{
'dtype': numpy.float16
},
{
'dtype': numpy.float32
},
{
'dtype': numpy.float64
},
],
))
from chainer.backends import cuda
from chainer import initializers
from chainer import testing
from chainer.testing import attr
import numpy
@testing.parameterize(*(
testing.product_dict(
[
{'target': initializers.Normal, '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)
@testing.parameterize(*testing.product_dict([
{
'shape': (2, 3, 4),
'y_shape': (4, 3, 4),
'xs_length': 2
},
{
'shape': (3, 4),
'y_shape': (6, 4),
'xs_length': 2
},
{
'shape': (3),
'y_shape': (2, 3),
'xs_length': 2
},
{
'shape': (),
'y_shape': (2, 1),
'xs_length': 2
},
{
'shape': (3, 4),
'y_shape': (3, 4),
'xs_length': 1
},
{
'shape': (3),
'y_shape': (1, 3),
'xs_length': 1
},
{
'shape': (),
'y_shape': (1, 1),
'xs_length': 1
},
], [
{
'dtype': numpy.float16
},
{
'dtype': numpy.float32
},
{
'dtype': numpy.float64
},
]))
from chainer import gradient_check
from chainer import testing
from chainer.testing import attr
from chainer.testing import condition
@testing.parameterize(*testing.product_dict(
[
# we assume insize as (2, 1)
# standard output size which is estimated with get_deconv_outsize
# function
{'cover_all': False, 'outsize': (4, 2)},
{'cover_all': True, 'outsize': (3, 1)},
{'cover_all': False, 'outsize': None, 'expected_outsize': (4, 2)},
{'cover_all': True, 'outsize': None, 'expected_outsize': (3, 1)},
# another sizes which can be outsize of insize (2, 1)
{'cover_all': False, 'outsize': (5, 2)},
{'cover_all': True, 'outsize': (4, 2)},
],
[
{'dtype': numpy.float16},
{'dtype': numpy.float32},
{'dtype': numpy.float64},
],
))
class TestUnpooling2D(unittest.TestCase):
def setUp(self):
self.N = 2
self.n_channels = 3
inh, inw = 2, 1
@testing.parameterize(*testing.product_dict([
{
'n_bbox': 3,
'label': (0, 1, 2),
'score': (0, 0.5, 1),
'label_names': ('c0', 'c1', 'c2')
},
{
'n_bbox': 3,
'label': (0, 1, 2),
'score': None,
'label_names': ('c0', 'c1', 'c2')
},
{
'n_bbox': 3,
'label': (0, 1, 2),
'score': (0, 0.5, 1),
'label_names': None
},
{
'n_bbox': 3,
'label': None,
'score': (0, 0.5, 1),
'label_names': ('c0', 'c1', 'c2')
},
{
'n_bbox': 3,
'label': None,
'score': (0, 0.5, 1),
'label_names': None
},
{
'n_bbox': 3,
'label': None,
'score': None,
'label_names': None
},
{
'n_bbox': 3,
'label': (0, 1, 1),
'score': (0, 0.5, 1),
'label_names': ('c0', 'c1', 'c2')
},
{
'n_bbox': 0,
'label': (),
'score': (),
'label_names': ('c0', 'c1', 'c2')
},
{
'n_bbox': 3,
'label': (0, 1, 2),
'score': (0, 0.5, 1),
'label_names': ('c0', 'c1', 'c2'),
'no_img': True
},
{
'n_bbox': 3,
'label': (0, 1, 2),
'score': (0, 0.5, 1),
'label_names': ('c0', 'c1', 'c2'),
'instance_colors': [(255, 0, 0), (0, 255, 0), (0, 0, 255),
(100, 100, 100)]
},
], [{
'sort_by_score': False
}, {
'sort_by_score': True
}]))
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
import chainerx
@testing.parameterize(*testing.product_dict(
testing.product({
'dtype': [numpy.float16, numpy.float32, numpy.float64],
}),
testing.product({
'shape': [None, (2, 3), (2, 2, 3), (2, 2, 2, 3)],
'axis': [1],
}) + [
{'shape': (2, 3), 'axis': 0},
{'shape': (2, 2, 3), 'axis': -1},
{'shape': (2, 2, 2, 3), 'axis': -4},
],
))
@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:
from chainer import gradient_check
from chainer import testing
from chainer.testing import attr
@testing.parameterize(*testing.product_dict(
[{'dtype': numpy.float16,
'forward_options': {'rtol': 1e-2, 'atol': 1e-2},
'backward_options': {'rtol': 1e-2, 'atol': 1e-3},
'double_backward_options': {'rtol': 3e-1, 'atol': 3e-1}},
{'dtype': numpy.float32,
'forward_options': {'rtol': 1e-2},
'backward_options': {'rtol': 1e-2, 'atol': 1e-3},
'double_backward_options': {'rtol': 1e-2, 'atol': 1e-3}},
{'dtype': numpy.float64,
'forward_options': {'rtol': 1e-2},
'backward_options': {'rtol': 1e-2, 'atol': 1e-3},
'double_backward_options': {'rtol': 1e-2, 'atol': 1e-3}},
],
testing.product({
'batchsize': [5, 10],
'input_dim': [2, 3],
'margin': [1, 2],
'reduce': ['mean', 'no'],
'label_dtype': [numpy.int32, numpy.int64]
})
))
class TestContrastive(unittest.TestCase):
def setUp(self):
x_shape = (self.batchsize, self.input_dim)
retry = 0
import chainer
from chainer.backends import cuda
from chainer import functions
from chainer import testing
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'},
]
@testing.parameterize(*testing.product_dict(
[
{
'in_shapes': [(3, 1, 4), (1, 2, 4)],
'out_shape': (3, 2, 4)
},
{
'in_shapes': [(3, 2, 4), (4, )],
'out_shape': (3, 2, 4)
},
{
'in_shapes': [(3, 2, 4), ()],
'out_shape': (3, 2, 4)
},
{
'in_shapes': [(3, 2, 4), (3, 2, 4)],
'out_shape': (3, 2, 4)
},
{
'in_shapes': [(), ()],
'out_shape': ()
},
{
'in_shapes': [(1, 1, 1), (1, )],
'out_shape': (1, 1, 1)
},
{
'in_shapes': [(1, 1, 1), ()],
'out_shape': (1, 1, 1)
},
{
'in_shapes': [(3, 2, 4)],
'out_shape': (3, 2, 4)
},
{
'in_shapes': [(3, 1, 4), (1, 2, 4), (3, 2, 1)],
'out_shape': (3, 2, 4)
},
{
'in_shapes': [(1, 0, 1), (2, )],
'out_shape': (1, 0, 2)
},
],
[
{
'dtype': numpy.float16
},
{
'dtype': numpy.float32
},
{
'dtype': numpy.float64
},
],
))
from chainer import functions
from chainer import gradient_check
from chainer import testing
from chainer.testing import attr
import chainerx
@testing.parameterize(*testing.product_dict(
[
{'shape': (3, 4), 'axis': 0, 'y_shape': (2, 3, 4)},
{'shape': (3, 4), 'axis': 1, 'y_shape': (3, 2, 4)},
{'shape': (3, 4), 'axis': 2, 'y_shape': (3, 4, 2)},
{'shape': (3, 4), 'axis': -1, 'y_shape': (3, 4, 2)},
{'shape': (3, 4), 'axis': -2, 'y_shape': (3, 2, 4)},
{'shape': (3, 4), 'axis': -3, 'y_shape': (2, 3, 4)},
{'shape': (), 'axis': 0, 'y_shape': (2,)},
{'shape': (), 'axis': -1, 'y_shape': (2,)},
],
[
{'dtype': numpy.float16},
{'dtype': numpy.float32},
{'dtype': numpy.float64},
]
))
class TestStack(unittest.TestCase):
def setUp(self):
self.xs = [
numpy.random.uniform(-1, 1, self.shape).astype(self.dtype),
numpy.random.uniform(-1, 1, self.shape).astype(self.dtype),
]
img, label = super(InvalidLabelDataset, self).get_example(i)[:2]
label += 1000
return img, label
@testing.parameterize(*(testing.product_dict([{
'dataset': LabelDataset,
'valid': True
}, {
'dataset': LabelDataset,
'valid': True,
'option': 'option'
}, {
'dataset': InvalidSampleSizeDataset,
'valid': False
}, {
'dataset': InvalidImageDataset,
'valid': False
}, {
'dataset': InvalidLabelDataset,
'valid': False
}], [{
'color': False
}, {
'color': True
}])))
class TestAssertIsLabelDataset(unittest.TestCase):
def test_assert_is_label_dataset(self):
if hasattr(self, 'option'):
dataset = self.dataset(self.color, self.option)
else: