def check_forward_consistency(self, use_cudnn='always'): x_cpu = chainer.Variable(self.x) W_cpu = chainer.Variable(self.W) b_cpu = None if self.nobias else chainer.Variable(self.b) y_cpu = F.deconvolution_nd(x_cpu, W_cpu, b_cpu, stride=self.stride, pad=self.pad, outsize=self.outsize, dilate=self.dilate, groups=self.groups) x_gpu = chainer.Variable(cuda.to_gpu(self.x)) W_gpu = chainer.Variable(cuda.to_gpu(self.W)) b_gpu = None if self.nobias else chainer.Variable(cuda.to_gpu(self.b)) with chainer.using_config('use_cudnn', use_cudnn): with chainer.using_config('autotune', self.autotune): y_gpu = F.deconvolution_nd(x_gpu, W_gpu, b_gpu, stride=self.stride, pad=self.pad, outsize=self.outsize, dilate=self.dilate, groups=self.groups) self.assertEqual(y_cpu.data.dtype, self.x_dtype) self.assertEqual(y_gpu.data.dtype, self.x_dtype) testing.assert_allclose(y_cpu.data, y_gpu.data.get(), **self.test_forward_options)
def test_estimated_outsize(self): x = numpy.random.uniform(-1, 1, (2, 3, 4)).astype(numpy.float32) W = numpy.random.uniform(-1, 1, (3, 2, 2)).astype(numpy.float32) stride = 1 pad = 10 with self.assertRaises(AssertionError): F.deconvolution_nd(x, W, stride=stride, pad=pad)
def check_array_supplied(self, x_ary, W_ary, b_ary): y_ary = F.deconvolution_nd(x_ary, W_ary, b_ary) x_var = chainer.Variable(x_ary) W_var = chainer.Variable(W_ary) b_var = chainer.Variable(b_ary) y_var = F.deconvolution_nd(x_var, W_var, b_var) testing.assert_allclose(y_ary.data, y_var.data)
def test_bias(self): # dtype x = numpy.random.uniform(-1, 1, (2, 3, 4)).astype(numpy.float32) W = numpy.random.uniform(-1, 1, (3, 2, 2)).astype(numpy.float32) b = numpy.random.uniform(-1, 1, (2,)).astype(numpy.int32) with self.assertRaises(type_check.InvalidType): F.deconvolution_nd(x, W, b=b) # ndim x = numpy.random.uniform(-1, 1, (2, 3, 4)).astype(numpy.float32) W = numpy.random.uniform(-1, 1, (3, 2, 2)).astype(numpy.float32) b = numpy.random.uniform(-1, 1, (2, 2)).astype(numpy.float32) with self.assertRaises(type_check.InvalidType): F.deconvolution_nd(x, W, b=b)
def f(*args): return F.deconvolution_nd(*args, stride=self.stride, pad=self.pad, outsize=self.outsize, dilate=self.dilate, groups=self.groups)
def check_forward_consistency_regression(self, x_data, W_data, b_data, use_cudnn='always'): x = chainer.Variable(x_data) W = chainer.Variable(W_data) b = None if self.nobias else chainer.Variable(b_data) with chainer.using_config('use_cudnn', use_cudnn): y_nd = F.deconvolution_nd(x, W, b, stride=self.stride, pad=self.pad, outsize=self.outsize, dilate=self.dilate) y_2d = F.deconvolution_2d(x, W, b, stride=self.stride, pad=self.pad, outsize=self.outsize, dilate=self.dilate) testing.assert_allclose(y_nd.data, y_2d.data, **self.test_forward_options)
def check_forward_consistency_regression(self, backend_config): inputs = self.generate_inputs() if self.nobias: x, W = inputs b = None else: x, W, b = inputs x = chainer.Variable(backend_config.get_array(x)) W = chainer.Variable(backend_config.get_array(W)) if b is not None: b = chainer.Variable(backend_config.get_array(b)) use_cudnn = backend_config.use_cudnn with chainer.using_config('use_cudnn', use_cudnn): y_nd = F.deconvolution_nd(x, W, b, stride=self.stride, pad=self.pad, outsize=self.outsize, dilate=self.dilate) y_2d = F.deconvolution_2d(x, W, b, stride=self.stride, pad=self.pad, outsize=self.outsize, dilate=self.dilate) testing.assert_allclose(y_nd.array, y_2d.array, **self.check_forward_options)
def check_forward_consistency(self, use_cudnn=True): x_cpu = chainer.Variable(self.x) W_cpu = chainer.Variable(self.W) b_cpu = None if self.nobias else chainer.Variable(self.b) y_cpu = F.deconvolution_nd( x_cpu, W_cpu, b_cpu, stride=self.stride, pad=self.pad, outsize=self.outsize, use_cudnn=use_cudnn) x_gpu = chainer.Variable(cuda.to_gpu(self.x)) W_gpu = chainer.Variable(cuda.to_gpu(self.W)) b_gpu = None if self.nobias else chainer.Variable(cuda.to_gpu(self.b)) y_gpu = F.deconvolution_nd( x_gpu, W_gpu, b_gpu, stride=self.stride, pad=self.pad, outsize=self.outsize, use_cudnn=use_cudnn) self.assertEqual(y_cpu.data.dtype, self.x_dtype) self.assertEqual(y_gpu.data.dtype, self.x_dtype) testing.assert_allclose( y_cpu.data, y_gpu.data.get(), **self.test_forward_options)
def forward(self, inputs, device): if self.nobias: x, W = inputs b = None else: x, W, b = inputs y = F.deconvolution_nd( x, W, b, stride=self.stride, pad=self.pad, outsize=self.outsize, dilate=self.dilate, groups=self.groups) return y,
def forward_expected(self, link, inputs): x, = inputs W = link.W b = link.b y = F.deconvolution_nd(x, W, b, outsize=self.outsize, stride=self.stride, pad=self.pad, groups=self.groups) return y.array,
def check_forward_consistency_regression(self, x_data, W_data, b_data, use_cudnn=True): x = chainer.Variable(x_data) W = chainer.Variable(W_data) b = None if self.nobias else chainer.Variable(b_data) y_nd = F.deconvolution_nd(x, W, b, stride=self.stride, pad=self.pad, outsize=self.outsize, use_cudnn=use_cudnn) y_2d = F.deconvolution_2d(x, W, b, stride=self.stride, pad=self.pad, outsize=self.outsize, use_cudnn=use_cudnn) testing.assert_allclose( y_nd.data, y_2d.data, **self.test_forward_options)
def __call__(self, x): """Applies N-dimensional convolution layer. Args: x (~chainer.Variable): Input image. Returns: ~chainer.Variable: Output of convolution. """ return deconvolution_nd( convolution_nd(x, self.W, self.b, self.stride, self.pad), self.W, self.b, self.stride, self.pad)
def check_forward_consistency(self, use_cudnn='always'): x_cpu = chainer.Variable(self.x) W_cpu = chainer.Variable(self.W) b_cpu = None if self.nobias else chainer.Variable(self.b) y_cpu = F.deconvolution_nd( x_cpu, W_cpu, b_cpu, stride=self.stride, pad=self.pad, outsize=self.outsize, dilate=self.dilate, groups=self.groups) x_gpu = chainer.Variable(cuda.to_gpu(self.x)) W_gpu = chainer.Variable(cuda.to_gpu(self.W)) b_gpu = None if self.nobias else chainer.Variable(cuda.to_gpu(self.b)) with chainer.using_config('use_cudnn', use_cudnn): with chainer.using_config('autotune', self.autotune): y_gpu = F.deconvolution_nd( x_gpu, W_gpu, b_gpu, stride=self.stride, pad=self.pad, outsize=self.outsize, dilate=self.dilate, groups=self.groups) self.assertEqual(y_cpu.data.dtype, self.x_dtype) self.assertEqual(y_gpu.data.dtype, self.x_dtype) testing.assert_allclose( y_cpu.data, y_gpu.data.get(), **self.test_forward_options)
def check_forward_consistency_regression(self, x_data, W_data, b_data, use_cudnn='always'): x = chainer.Variable(x_data) W = chainer.Variable(W_data) b = None if self.nobias else chainer.Variable(b_data) with chainer.using_config('use_cudnn', use_cudnn): y_nd = F.deconvolution_nd(x, W, b, stride=self.stride, pad=self.pad, outsize=self.outsize, dilate=self.dilate) y_2d = F.deconvolution_2d(x, W, b, stride=self.stride, pad=self.pad, outsize=self.outsize, dilate=self.dilate) testing.assert_allclose( y_nd.data, y_2d.data, **self.test_forward_options)
def forward(self, x): if self.W.array is None: self._initialize_params(x.shape[1]) pad_width = [(0, 0), (0, 0)] + list(map(lambda x: (x, x), self.pad)) x = F.pad(x, pad_width, self.pad_mode) return F.deconvolution_nd(x, self.W, b=self.b, stride=self.stride, pad=0, outsize=self.outsize, dilate=self.dilate, groups=self.groups)
def forward_expected(self, inputs): """ Current forward_expected implementation depends on F.deconvolution_nd itself and thus it's only capable of checking consistency between backends, not absolute correctness of computations """ if self.nobias: x, W = inputs b = None else: x, W, b = inputs y_expected = F.deconvolution_nd( x, W, b, stride=self.stride, pad=self.pad, outsize=self.outsize, dilate=self.dilate, groups=self.groups) return y_expected.array,
def test_data_and_weight(self): # dtype of data x = numpy.random.uniform(-1, 1, (2, 3, 4)).astype(numpy.int32) W = numpy.random.uniform(-1, 1, (3, 2, 2)).astype(numpy.float32) with self.assertRaises(type_check.InvalidType): F.deconvolution_nd(x, W) # dtype of weight x = numpy.random.uniform(-1, 1, (2, 3, 4)).astype(numpy.float32) W = numpy.random.uniform(-1, 1, (3, 2, 2)).astype(numpy.int32) with self.assertRaises(type_check.InvalidType): F.deconvolution_nd(x, W) # ndim of weight x = numpy.random.uniform(-1, 1, (2, 3, 4, 4)).astype(numpy.float32) W = numpy.random.uniform(-1, 1, (3, 2, 2)).astype(numpy.float32) with self.assertRaises(type_check.InvalidType): F.deconvolution_nd(x, W) # shapes of data and weight x = numpy.random.uniform(-1, 1, (2, 3, 4)).astype(numpy.float32) W = numpy.random.uniform(-1, 1, (2, 2, 2)).astype(numpy.float32) with self.assertRaises(type_check.InvalidType): F.deconvolution_nd(x, W)
def test_deconv3d(self): (x, W, b) = self._get_data(3) testing.assert_allclose( F.deconvolution_nd(x, W, b).data, F.deconvolution_3d(x, W, b).data)
def f(*args): y = F.deconvolution_nd( *args, stride=self.stride, pad=self.pad, outsize=self.outsize, dilate=self.dilate, groups=self.groups) return y * y # make the function nonlinear
def test_supplied_outsize(self): x = numpy.random.uniform(-1, 1, (2, 3, 4)).astype(numpy.float32) W = numpy.random.uniform(-1, 1, (3, 2, 2)).astype(numpy.float32) outsize = (10,) with self.assertRaises(type_check.InvalidType): F.deconvolution_nd(x, W, outsize=outsize)
def f(*args): return F.deconvolution_nd(*args, stride=self.stride, pad=self.pad, outsize=self.outsize)
def forward(self): x = chainer.Variable(self.x) W = chainer.Variable(self.W) return F.deconvolution_nd(x, W, None, stride=1, pad=1)
def f(*args): return F.deconvolution_nd( *args, stride=self.stride, pad=self.pad, outsize=self.outsize, dilate=self.dilate, groups=self.groups)
def f(*args): y = F.deconvolution_nd( *args, stride=self.stride, pad=self.pad, outsize=self.outsize) return y * y # make the function nonlinear