def check_negative(self, xp, func_name, input, eps, nout): # Should be differentiable func = getattr(self, '_func_{}'.format(func_name)) grad_outputs = [ xp.random.uniform(-1, 1, input.shape).astype(input.dtype) for _ in range(nout)] def f(): return func(input) * nout try: gradient_check.numerical_grad( f, (input,), grad_outputs, eps=eps, detect_nondifferentiable=True) except gradient_check.NondifferentiableError as e: raise AssertionError( 'Function `{}` is expected to be differentiable, ' 'but determined to be non-differentiable.\n\n' 'eps: {}\n' 'input: {}\n' 'xp: {}\n\n' '{}: {}' ''.format( func_name, eps, input, xp.__name__, e.__class__.__name__, e))
def check_backward(self, x_data, W_data, b_data, y_grad): x = chainer.Variable(x_data) W = chainer.Variable(W_data) b = None if b_data is None else chainer.Variable(b_data) y = functions.convolution_2d(x, W, b, stride=self.stride, pad=self.pad, use_cudnn=self.use_cudnn) y.grad = y_grad y.backward() func = y.creator if b is None: f = lambda: func.forward((x.data, W.data)) gx, gW = gradient_check.numerical_grad(f, (x.data, W.data), (y.grad, ), eps=1e-2) else: f = lambda: func.forward((x.data, W.data, b.data)) gx, gW, gb = gradient_check.numerical_grad( f, (x.data, W.data, b.data), (y.grad, ), eps=1e-2) gradient_check.assert_allclose(gx, x.grad) gradient_check.assert_allclose(gW, W.grad) if b is not None: gradient_check.assert_allclose(gb, b.grad)
def check_backward(self, x_data, W_data, b_data, y_grad): x = chainer.Variable(x_data) W = chainer.Variable(W_data) if b_data is None: y = functions.maxout(x, W) else: b = chainer.Variable(b_data) y = functions.maxout(x, W, b) y.grad = y_grad y.backward() func = y.creator if b_data is None: f = lambda: func.forward((x.data, W.data)) gx, gW = gradient_check.numerical_grad(f, (x.data, W.data), (y.grad, ), eps=1e-2) else: f = lambda: func.forward((x.data, W.data, b.data)) gx, gW, gb = gradient_check.numerical_grad( f, (x.data, W.data, b.data), (y.grad, ), eps=1e-2) gradient_check.assert_allclose(gx, x.grad, atol=1e-2) gradient_check.assert_allclose(gW, W.grad, atol=1e-2) if b_data is not None: gradient_check.assert_allclose(gb, b.grad, atol=1e-2)
def check_negative(self, xp, func_name, inputs, eps, nout): # Should be differentiable func = getattr(self, '_func_{}'.format(func_name)) grad_outputs = [ xp.random.uniform(-1, 1, _.shape).astype(_.dtype) for _ in inputs ] def f(): return func(*inputs) * nout try: gradient_check.numerical_grad(f, inputs, grad_outputs, eps=eps, detect_nondifferentiable=True) except gradient_check.NondifferentiableError as e: raise AssertionError( 'Function `{}` is expected to be differentiable, ' 'but determined to be non-differentiable.\n\n' 'eps: {}\n' 'inputs: {}\n' 'xp: {}\n\n' '{}: {}' ''.format(func_name, eps, inputs, xp.__name__, e.__class__.__name__, e))
def check_positive(self, xp, func_name, input, eps, nout): # Should be non-differentiable func = getattr(self, '_func_{}'.format(func_name)) grad_outputs = [ xp.random.uniform(-1, 1, input.shape).astype(input.dtype) for _ in range(nout) ] def f(): return func(input) * nout try: gradient_check.numerical_grad(f, (input, ), grad_outputs, eps=eps, detect_nondifferentiable=True) except gradient_check.NondifferentiableError: pass else: raise AssertionError( 'Function `{}` is expected to be non-differentiable, ' 'but determined to be differentiable.\n\n' 'eps: {}\n' 'input: {}\n' 'xp: {}\n' ''.format(func_name, eps, input, xp.__name__))
def check_backward(self, x0_data, x1_data, t_data): x0 = chainer.Variable(x0_data) x1 = chainer.Variable(x1_data) t = chainer.Variable(t_data) loss = functions.contrastive(x0, x1, t, self.margin) loss.backward() self.assertEqual(None, t.grad) func = loss.creator f = lambda: func.forward((x0.data, x1.data, t.data)) gx0, = gradient_check.numerical_grad(f, (x0.data, ), (1, )) gx1, = gradient_check.numerical_grad(f, (x1.data, ), (1, )) gradient_check.assert_allclose(gx0, x0.grad, rtol=1e-4, atol=1e-4) gradient_check.assert_allclose(gx1, x1.grad, rtol=1e-4, atol=1e-4)
def check_backward(self, x0_data, x1_data, t_data, use_cudnn=True): x0 = chainer.Variable(x0_data) x1 = chainer.Variable(x1_data) t = chainer.Variable(t_data) loss = contrastive(x0, x1, t, use_cudnn) loss.backward() self.assertEqual(None, t.grad) func = loss.creator f = lambda: func.forward((x0.data, x1.data, t.data)) gx0, = gradient_check.numerical_grad(f, (x0.data, ), (1, )) gx1, = gradient_check.numerical_grad(f, (x1.data, ), (1, )) gradient_check.assert_allclose(gx0, x0.grad) gradient_check.assert_allclose(gx1, x1.grad)
def check_backward(self, h_data, x_data, y_grad): h = chainer.Variable(h_data) x = chainer.Variable(x_data) y = self._forward(self.link, h, x) y.grad = y_grad y.backward() def f(): return _gru(self.link, h_data, x_data), gx, = gradient_check.numerical_grad(f, (x.data,), (y_grad,)) testing.assert_allclose(gx, x.grad, atol=1e-3) if isinstance(self.link, links.StatelessGRU): gh, = gradient_check.numerical_grad(f, (h.data,), (y_grad,)) testing.assert_allclose(gh, h.grad, atol=1e-3)
def check_backward(self, h_data, x_data, y_grad): h = chainer.Variable(h_data) x = chainer.Variable(x_data) y = self._forward(self.link, h, x) y.grad = y_grad y.backward() def f(): return _gru(self.link, h_data, x_data), gx, = gradient_check.numerical_grad(f, (x.data,), (y.grad,)) testing.assert_allclose(gx, x.grad, atol=1e-3) if isinstance(self.link, links.GRU): gh, = gradient_check.numerical_grad(f, (h.data,), (y.grad,)) testing.assert_allclose(gh, h.grad, atol=1e-3)
def check_different_eps(self, x, y): def f(): if -1 < x < 1: return x.copy(), elif -2 < x < 2: return 2 * x, else: return 0, gx, = gradient_check.numerical_grad(f, (x, ), (y, ), eps=0.5) self.assertEqual(gx, 1.) gx, = gradient_check.numerical_grad(f, (x, ), (y, ), eps=1.5) self.assertEqual(gx, 2.) gx, = gradient_check.numerical_grad(f, (x, ), (y, ), eps=2.5) self.assertEqual(gx, 0.)
def check_backward(self, x0_data, x1_data, t_data, use_cudnn=True): x0 = chainer.Variable(x0_data) x1 = chainer.Variable(x1_data) t = chainer.Variable(t_data) loss = contrastive(x0, x1, t, use_cudnn) loss.backward() self.assertEqual(None, t.grad) func = loss.creator f = lambda: func.forward((x0.data, x1.data, t.data)) gx0, = gradient_check.numerical_grad(f, (x0.data,), (1,)) gx1, = gradient_check.numerical_grad(f, (x1.data,), (1,)) gradient_check.assert_allclose(gx0, x0.grad) gradient_check.assert_allclose(gx1, x1.grad)
def check_different_eps(self, x, y): def f(): if -1 < x < 1: return x.copy(), elif -2 < x < 2: return 2 * x, else: return 0, gx, = gradient_check.numerical_grad(f, (x,), (y,), eps=0.5) self.assertEqual(gx, 1.) gx, = gradient_check.numerical_grad(f, (x,), (y,), eps=1.5) self.assertEqual(gx, 2.) gx, = gradient_check.numerical_grad(f, (x,), (y,), eps=2.5) self.assertEqual(gx, 0.)
def check_backward(self, x0_data, x1_data, t_data): x0 = chainer.Variable(x0_data) x1 = chainer.Variable(x1_data) t = chainer.Variable(t_data) loss = functions.contrastive(x0, x1, t, self.margin) loss.backward() self.assertEqual(None, t.grad) func = loss.creator f = lambda: func.forward((x0.data, x1.data, t.data)) gx0, = gradient_check.numerical_grad(f, (x0.data,), (1,)) gx1, = gradient_check.numerical_grad(f, (x1.data,), (1,)) gradient_check.assert_allclose(gx0, x0.grad, rtol=1e-4, atol=1e-4) gradient_check.assert_allclose(gx1, x1.grad, rtol=1e-4, atol=1e-4)
def check_backward(update, atom_data, adj_data, y_grad): """Check gradient of GGNNUpdate. This function is different from other backward tests. Because of GRU, reset_state method has to be called explicitly before gradient calculation. Args: update (callable): atom_data (numpy.ndarray): adj_data (numpy.ndarray): y_grad (numpy.ndarray): """ atom = chainer.Variable(atom_data) update.reset_state() y = update(atom, adj_data) y.grad = y_grad y.backward() def f(): update.reset_state() return update(atom_data, adj_data).data, gx, = gradient_check.numerical_grad(f, (atom.data, ), (y.grad, )) numpy.testing.assert_allclose(cuda.to_cpu(gx), cuda.to_cpu(atom.grad), atol=1e-3, rtol=1e-3) return gx
def check_backward(update, atom_data, adj_data, y_grad): # type: (MPNNUpdate, numpy.ndarray, numpy.ndarray, numpy.ndarray) -> None """Check gradient of MPNNUpdate. This function is different from other backward tests. Because of GRU, reset_state method has to be called explicitly before gradient calculation. Args: update (callable): atom_data (numpy.ndarray): adj_data (numpy.ndarray): y_grad (numpy.ndarray): """ atom = chainer.Variable(atom_data) adj = chainer.Variable(adj_data) update.reset_state() y = update(atom, adj) y.grad = y_grad y.backward() def f(): # type: () -> numpy.ndarray update.reset_state() return update(atom_data, adj_data).data, gx, = gradient_check.numerical_grad(f, (atom.data, ), (y.grad, )) numpy.testing.assert_allclose(gx, atom.grad, atol=1e-3, rtol=1e-3)
def check_backward(readout, atom_data, y_grad): # type: (Set2Set, numpy.ndarray, numpy.ndarray) -> None """Check gradient of Set2Set. This function is different from other backward tests. Because of LSTM, reset_state method has to be called explicitly before gradient calculation. Args: readout: atom_data: y_grad: """ atom = chainer.Variable(atom_data) readout.reset_state() y = readout(atom) y.grad = y_grad y.backward() def f(): readout.reset_state() return readout(atom_data).data, gx, = gradient_check.numerical_grad(f, (atom.data, ), (y.grad, )) numpy.testing.assert_allclose(gx, atom.grad, atol=1e-2, rtol=1e-2)
def check_backward(self, t_data, xs_data, l_length, x_length, grad, gx): xs = tuple(chainer.Variable(x_data) for x_data in xs_data) t = chainer.Variable(t_data) loss = functions.connectionist_temporal_classification( xs, t, 2, input_length=chainer.Variable(x_length), label_length=chainer.Variable(l_length)) loss.grad = grad loss.backward() func = loss.creator xs_data = tuple(x.data for x in xs) f = lambda: func.forward(( x_length, l_length, t.data, ) + xs_data) gx_0, gx_1, gx_2, gx_3 = gradient_check.numerical_grad( f, (xs_data), (gx, )) gradient_check.assert_allclose(xs[0].grad, gx_0, atol=1e-04) gradient_check.assert_allclose(xs[1].grad, gx_1, atol=1e-04) gradient_check.assert_allclose(xs[2].grad, gx_2, atol=1e-04) gradient_check.assert_allclose(xs[3].grad, gx_3, atol=1e-04)
def check_reference(self, x): # A returned value and an input refers the same memory. # See issue #488 def func(): return x, gx, = gradient_check.numerical_grad(func, (x,), (1,)) testing.assert_allclose(cuda.to_cpu(gx), 1)
def check_backward(readout, atom_data, y_grad): # type: (Set2Set, numpy.ndarray, numpy.ndarray) -> None """Check gradient of Set2Set. This function is different from other backward tests. Because of LSTM, reset_state method has to be called explicitly before gradient calculation. Args: readout: atom_data: y_grad: """ atom = chainer.Variable(atom_data) readout.reset_state() y = readout(atom) y.grad = y_grad y.backward() def f(): readout.reset_state() return readout(atom_data).data, gx, = gradient_check.numerical_grad(f, (atom.data, ), (y.grad, )) numpy.testing.assert_allclose(cuda.to_cpu(gx), cuda.to_cpu(atom.grad), atol=1e-2, rtol=1e-2)
def check_backward(self, x_data, t_data, y_grad): x = chainer.Variable(x_data) t = chainer.Variable(t_data) W = self.link.W y = self.link(x, t) y.grad = y_grad y.backward() # fix samples negative_sampling.NegativeSamplingFunction.samples = y.creator.samples def f(): return self.link(x, t).data, gx, gW = gradient_check.numerical_grad(f, (x.data, W.data), (y.grad, ), eps=1e-2) del negative_sampling.NegativeSamplingFunction.samples # clean up gradient_check.assert_allclose(cuda.to_cpu(gx), cuda.to_cpu(x.grad), atol=1.e-4) gradient_check.assert_allclose(cuda.to_cpu(gW), cuda.to_cpu(W.grad), atol=1.e-4)
def check_backward(self, x_data, y_grad): x = chainer.Variable(x_data) y = self.link(x) y.grad = y_grad y.backward() f = lambda: (self.link(x).data,) gx, gW = gradient_check.numerical_grad( f, (x.data, self.link.W.data), (y.grad,), eps=1e-2) if not self.nobias: gb, = gradient_check.numerical_grad( f, (self.link.b.data,), (y.grad,), eps=1e-2) gradient_check.assert_allclose(gx, x.grad) gradient_check.assert_allclose(gW, self.link.W.grad) if not self.nobias: gradient_check.assert_allclose(gb, self.link.b.grad)
def check_backward(self, x_data, y_grad): x = chainer.Variable(x_data) y = self.link(x) y.grad = y_grad y.backward() f = lambda: (self.link(x).data,) gW, = gradient_check.numerical_grad(f, (self.link.W.data,), (y.grad,)) gradient_check.assert_allclose(gW, self.link.W.grad)
def check_backward(self, x_data, gy_data, use_cudnn=True): x = Variable(x_data) y = tanh(x, use_cudnn=use_cudnn) y.grad = gy_data y.backward() func = y.creator f = lambda: func.forward((x.data,)) gx, = numerical_grad(f, (x.data,), (y.grad,)) assert_allclose(gx, x.grad)
def check_backward(self, x_data, gy_data, use_cudnn=True): x = chainer.Variable(x_data) y = functions.tanh(x, use_cudnn=use_cudnn) y.grad = gy_data y.backward() func = y.creator f = lambda: func.forward((x.data, )) gx, = gradient_check.numerical_grad(f, (x.data, ), (y.grad, )) gradient_check.assert_allclose(gx, x.grad)
def check_backward(self, x_data, gy_data, use_cudnn=True): x = chainer.Variable(x_data) y = functions.tanh(x, use_cudnn=use_cudnn) y.grad = gy_data y.backward() func = y.creator f = lambda: func.forward((x.data,)) gx, = gradient_check.numerical_grad(f, (x.data,), (y.grad,)) gradient_check.assert_allclose(gx, x.grad)
def check_backward(self, x_data, y_grad): x = chainer.Variable(x_data) y = self.link(x) y.grad = y_grad y.backward() f = lambda: (self.link(x).data, ) gW, = gradient_check.numerical_grad(f, (self.link.W.data, ), (y.grad, )) gradient_check.assert_allclose(gW, self.link.W.grad)
def check_backward(self, x_data, y_grad): x = chainer.Variable(x_data) y = self.link(x) y.grad = y_grad y.backward() f = lambda: (self.link(x).data, ) gx, gW = gradient_check.numerical_grad(f, (x.data, self.link.W.data), (y.grad, ), eps=1e-2) if not self.nobias: gb, = gradient_check.numerical_grad(f, (self.link.b.data, ), (y.grad, ), eps=1e-2) gradient_check.assert_allclose(gx, x.grad) gradient_check.assert_allclose(gW, self.link.W.grad) if not self.nobias: gradient_check.assert_allclose(gb, self.link.b.grad)
def check_backward(self, x_data, y_grad): x = Variable(x_data) y = self.func(x) y.grad = y_grad y.backward() func = y.creator f = lambda: func.forward((x.data,)) gW, = numerical_grad(f, (func.W,), (y.grad,)) assert_allclose(gW, func.gW)
def check_backward(self, x_data, y_grad): x = chainer.Variable(x_data) y = self.func(x) y.grad = y_grad y.backward() func = y.creator f = lambda: func.forward((x.data, )) gW, = gradient_check.numerical_grad(f, (func.W, ), (y.grad, )) gradient_check.assert_allclose(gW, func.gW)
def check_backward(self, x_data, y_grad): x = chainer.Variable(x_data) y = functions.expand_dims(x, self.axis) y.grad = y_grad y.backward() func = y.creator f = lambda: func.forward((x_data,)) gx, = gradient_check.numerical_grad(f, (x_data,), (y_grad,)) gradient_check.assert_allclose(cuda.to_cpu(x.grad), cuda.to_cpu(gx))
def check_backward(self, x_data, y_grad): x = Variable(x_data) y = leaky_relu(x, slope=self.slope) y.grad = y_grad y.backward() func = y.creator f = lambda: func.forward((x.data, )) gx, = numerical_grad(f, (x.data, ), (y.grad, )) assert_allclose(gx, x.grad)
def check_backward(self, x_data, y_grad): x = chainer.Variable(x_data) y = functions.leaky_relu(x, slope=self.slope) y.grad = y_grad y.backward() func = y.creator f = lambda: func.forward((x.data,)) gx, = gradient_check.numerical_grad(f, (x.data,), (y.grad,)) gradient_check.assert_allclose(gx, x.grad)
def check_backward(self, x_data, y_grad, use_cudnn=True): x = chainer.Variable(x_data) y = functions.max_pooling_2d(x, 3, stride=2, pad=1, cover_all=self.cover_all, use_cudnn=use_cudnn) y.grad = y_grad y.backward() func = y.creator f = lambda: func.forward((x.data,)) gx, = gradient_check.numerical_grad(f, (x.data,), (y.grad,)) gradient_check.assert_allclose(cuda.to_cpu(gx), cuda.to_cpu(x.grad))
def check_backward(self, op, x_data, y_grad): x = chainer.Variable(x_data) y = op(x, self.value) y.grad = y_grad y.backward() func = y.creator f = lambda: func.forward((x.data, )) gx, = gradient_check.numerical_grad(f, (x.data, ), (y.grad, )) gradient_check.assert_allclose(gx, x.grad)
def check_backward(self, x_data, y_grad, axis=None, keepdims=False): x = chainer.Variable(x_data) y = functions.max(x, axis=axis, keepdims=keepdims) y.grad = y_grad y.backward() func = y.creator f = lambda: func.forward((x.data.copy(),)) gx, = gradient_check.numerical_grad(f, (x.data,), (y.grad,), eps=1e-5) gradient_check.assert_allclose(gx, x.grad, rtol=1e-3, atol=1e-3)
def check_backward(self, x_data, y_grad): x = chainer.Variable(x_data) y = self.link(x) y.grad = y_grad y.backward() f = lambda: (self.link(x).data, ) if self.initial_bias is None: gx, gW = gradient_check.numerical_grad( f, (x.data, self.link.W.data), (y.grad, ), eps=1e-4) else: gx, gW, gb = gradient_check.numerical_grad( f, (x.data, self.link.W.data, self.link.b.data), (y.grad, ), eps=1e-4) gradient_check.assert_allclose(gx, x.grad, atol=1e-2) gradient_check.assert_allclose(gW, self.link.W.grad, atol=1e-2) if self.initial_bias is not None: gradient_check.assert_allclose(gb, self.link.b.grad, atol=1e-2)
def check_backward(self, op, x_data, y_grad): x = Variable(x_data) y = op(x) y.grad = y_grad y.backward() func = y.creator f = lambda: func.forward((x.data, )) gx, = numerical_grad(f, (x.data, ), (y.grad, )) assert_allclose(gx, x.grad)
def check_backward(self, random_array, random_grad_array): x = chainer.Variable(random_array) y = functions.depth2space(x, 2) y.grad = random_grad_array y.backward() def func(): return (functions.depth2space(x, 2).data,) gx, = gradient_check.numerical_grad(func, (x.data,), (y.grad,)) testing.assert_allclose(x.grad, gx, rtol=0.0001)
def check_backward(self, x_data, y_grad): x = chainer.Variable(x_data) y = functions.local_response_normalization(x) y.grad = y_grad y.backward() func = y.creator f = lambda: func.forward((x.data,)) gx, = gradient_check.numerical_grad(f, (x.data,), (y.grad,), eps=1) gradient_check.assert_allclose(gx, x.grad, atol=1e-3)
def check_backward(self, x_data, y_grad, use_cudnn=True): x = Variable(x_data) y = average_pooling_2d(x, 3, stride=2, pad=1, use_cudnn=use_cudnn) y.grad = y_grad y.backward() func = y.creator f = lambda: func.forward((x.data, )) gx, = numerical_grad(f, (x.data, ), (y.grad, ), eps=1e-2) assert_allclose(to_cpu(gx), to_cpu(x.grad))
def check_backward(self, x_data, y_grad): x = Variable(x_data) y = local_response_normalization(x) y.grad = y_grad y.backward() func = y.creator f = lambda: func.forward((x.data,)) gx, = numerical_grad(f, (x.data,), (y.grad,), eps=1) assert_allclose(gx, x.grad, atol=1e-3)
def check_backward(self, data, grad): x = chainer.Variable(data) bx = functions.broadcast_to(x, self.out_shape) func = bx.creator f = lambda: func.forward((data,)) bx.grad = grad bx.backward() gx, = gradient_check.numerical_grad(f, (data,), (bx.grad,)) gradient_check.assert_allclose(gx, x.grad)
def check_backward(self, op, x_data, y_grad): x = Variable(x_data) y = op(x) y.grad = y_grad y.backward() func = y.creator f = lambda: func.forward((x.data,)) gx, = numerical_grad(f, (x.data,), (y.grad,)) assert_allclose(gx, x.grad)
def check_backward(self, op, x_data, y_grad): x = chainer.Variable(x_data) y = op(x, self.value) y.grad = y_grad y.backward() func = y.creator f = lambda: func.forward((x.data,)) gx, = gradient_check.numerical_grad(f, (x.data,), (y.grad,)) gradient_check.assert_allclose(gx, x.grad)
def test_backward_cpu(self): x = Variable(np.random.randn(3, 2).astype(np.float32)) y = F.relu(x) y.grad = np.random.randn(3, 2).astype(np.float32) y.backward() def f(): return F.relu(x).data, gx, = gradient_check.numerical_grad(f, (x.data, ), (y.grad, )) testing.assert_allclose(gx, x.grad)
def check_backward(self, x_data, W_data, b_data, y_grad): x = chainer.Variable(x_data) W = chainer.Variable(W_data) b = None if b_data is None else chainer.Variable(b_data) y = functions.linear(x, W, b) y.grad = y_grad y.backward() func = y.creator if b_data is None: f = lambda: func.forward((x.data, W.data)) gx, gW = gradient_check.numerical_grad(f, (x.data, W.data), (y.grad,), eps=1e-2) else: f = lambda: func.forward((x.data, W.data, b.data)) gx, gW, gb = gradient_check.numerical_grad(f, (x.data, W.data, b.data), (y.grad,), eps=1e-2) gradient_check.assert_allclose(gx, x.grad) gradient_check.assert_allclose(gW, W.grad) if b_data is not None: gradient_check.assert_allclose(gb, b.grad)
def check_backward(self, x_data, y_grad, use_cudnn=True): x = Variable(x_data) y = average_pooling_2d(x, 3, stride=2, pad=1, use_cudnn=use_cudnn) y.grad = y_grad y.backward() func = y.creator f = lambda: func.forward((x.data,)) gx, = numerical_grad(f, (x.data,), (y.grad,), eps=1e-2) assert_allclose(to_cpu(gx), to_cpu(x.grad))
def check_backward(self, x_data, y_grad): x = chainer.Variable(x_data) y = functions.swapaxes(x, self.axis1, self.axis2) y.grad = y_grad y.backward() func = y.creator f = lambda: func.forward((x.data.copy(),)) gx, = gradient_check.numerical_grad(f, (x.data,), (y.grad,), eps=1e-5) gradient_check.assert_allclose(gx, x.grad, rtol=1e-5)
def check_backward(self, c_data, h_data, x_data, y_grad): x = chainer.Variable(x_data) y = self._forward(self.link, x) y.grad = y_grad y.backward() def f(): c, y = _peephole(self.link, c_data, h_data, x_data) return y, gx, = gradient_check.numerical_grad(f, (x.data,), (y.grad,)) gradient_check.assert_allclose(gx, x.grad, atol=1e-3)
def check_backward(self, c_data, h_data, x_data, y_grad): x = chainer.Variable(x_data) y = self._forward(self.link, x) y.grad = y_grad y.backward() def f(): c, y = _peephole(self.link, c_data, h_data, x_data) return y, gx, = gradient_check.numerical_grad(f, (x.data,), (y_grad,)) testing.assert_allclose(gx, x.grad, atol=1e-3)
def _check_backward(e1, e2, y_grad, link, bias): e1 = chainer.Variable(e1) e2 = chainer.Variable(e2) y = link(e1, e2) y.grad = y_grad y.backward() f = lambda: (link(e1, e2).data, ) ge1, ge2, gW = gradient_check.numerical_grad( f, (e1.data, e2.data, link.W.data), (y.grad, ), eps=1e-2) gradient_check.assert_allclose(ge1, e1.grad, rtol=1e-3) gradient_check.assert_allclose(ge2, e2.grad, rtol=1e-3) gradient_check.assert_allclose(gW, link.W.grad, rtol=1e-3) if bias: gV1, gV2, gb = gradient_check.numerical_grad( f, (link.V1.data, link.V2.data, link.b.data), (y.grad, ), eps=1e-2) gradient_check.assert_allclose(gV1, link.V1.grad, rtol=1e-3) gradient_check.assert_allclose(gV2, link.V2.grad, rtol=1e-3) gradient_check.assert_allclose(gb, link.b.grad, rtol=1e-3)
def check_backward(self, x_data, y_grad): x = chainer.Variable(x_data) y = functions.leaky_relu(x, slope=self.slope) y.grad = y_grad y.backward() func = y.creator f = lambda: func.forward((x.data, )) gx, = gradient_check.numerical_grad(f, (x.data, ), (y.grad, )) gradient_check.assert_allclose(gx, x.grad)
def check_backward(self, x_data, y_grad): x = Variable(x_data) y = leaky_relu(x, slope=self.slope) y.grad = y_grad y.backward() func = y.creator f = lambda: func.forward((x.data,)) gx, = numerical_grad(f, (x.data,), (y.grad,)) assert_allclose(gx, x.grad)
def check_backward(self, x_data, y_grad, use_cudnn=True): x = chainer.Variable(x_data) y = functions.spatial_pyramid_pooling_2d(x, self.pyramid_height, self.pooling_class, use_cudnn=use_cudnn) y.grad = y_grad y.backward() func = y.creator f = lambda: func.forward((x.data,)) gx, = gradient_check.numerical_grad(f, (x.data,), (y.grad,)) gradient_check.assert_allclose(cuda.to_cpu(gx), cuda.to_cpu(x.grad), atol=1e-04)
def check_backward(self, x_data, y_grad): x = chainer.Variable(x_data) y = functions.dropout(x, self.ratio) creator = y.creator y.grad = y_grad y.backward() def f(): y = _dropout(x_data, creator) return y, gx, = gradient_check.numerical_grad(f, (x_data, ), (y.grad, ), eps=0.1) testing.assert_allclose(gx, x.grad, **self.check_backward_options)