def test_irfft_ortho(): def fun(x): return np.fft.irfft(x, norm='ortho') D = 4 mat = npr.randn(D, D) / 10.0 # ensure hermitian by doing a fft mat = np.fft.rfft(mat) check_grads(fun)(mat)
def test_div(): fun = lambda x, y : x / y make_gap_from_zero = lambda x : np.sqrt(x **2 + 0.5) for arg1, arg2 in arg_pairs(): arg1 = make_gap_from_zero(arg1) arg2 = make_gap_from_zero(arg2) check_grads(fun)(arg1, arg2)
def test_items_values_keys(): def fun(input_dict): A = 0. B = 0. for i, (k, v) in enumerate(sorted(input_dict.items(), key=op.itemgetter(0))): A = A + np.sum(np.sin(v)) * (i + 1.0) B = B + np.sum(np.cos(v)) for v in input_dict.values(): A = A + np.sum(np.sin(v)) for k in sorted(input_dict.keys()): A = A + np.sum(np.cos(input_dict[k])) return A + B def d_fun(input_dict): g = grad(fun)(input_dict) A = np.sum(g['item_1']) B = np.sum(np.sin(g['item_1'])) C = np.sum(np.sin(g['item_2'])) return A + B + C input_dict = {'item_1' : npr.randn(5, 6), 'item_2' : npr.randn(4, 3), 'item_X' : npr.randn(2, 4)} check_grads(fun)(input_dict) check_grads(d_fun)(input_dict)
def test_irfftn(): def fun(x): return np.fft.irfftn(x) D = 4 mat = npr.randn(D, D, D) / 10.0 # ensure hermitian by doing a fft mat = np.fft.rfftn(mat) check_grads(fun)(mat)
def test_irfftn_subset(): def fun(x): return np.fft.irfftn(x)[(0, 1, 0), (3, 3, 2)] D = 4 mat = npr.randn(D, D, D) / 10.0 # ensure hermitian by doing a fft mat = np.fft.rfftn(mat) check_grads(fun)(mat)
def check_fft_s(fft_fun, D): def fun(x): return fft_fun(x, s=s, axes=axes) mat = npr.randn(D,D,D) / 10.0 mat = match_complex(fft_fun, mat) s = [D + 2, D - 2] axes = [0,2] check_grads(fun)(mat)
def test_mod(): fun = lambda x, y : x % y make_gap_from_zero = lambda x : np.sqrt(x **2 + 0.5) for arg1, arg2 in arg_pairs(): if not arg1 is arg2: # Gradient undefined at x == y arg1 = make_gap_from_zero(arg1) arg2 = make_gap_from_zero(arg2) check_grads(fun)(arg1, arg2)
def test_slogdet(): def fun(x): sign, logdet = np.linalg.slogdet(x) return logdet D = 6 mat = npr.randn(D, D) check_grads(fun)(mat) check_grads(fun)(-mat)
def test_svd_tall_2d(): def fun(x): u, s, v = np.linalg.svd(x, full_matrices=False) return tuple((u, s, v)) return grad(fun)(x) m = 5 n = 3 mat = npr.randn(m, n) check_grads(fun)(mat)
def test_index_slice_fanout(): A = npr.randn(5, 6, 4) def fun(x): y = x[::-1, 2:4, :] z = x[::-1, 3:5, :] return y + z check_grads(fun)(A)
def test_complex_separate_real_and_imaginary(): def fun(a): r, i = np.real(a), np.imag(a) a = np.abs(r)**1.4 + np.abs(i)**1.3 return np.sum(np.sin(a)) d_fun = lambda x : grad(fun)(x) A = npr.randn(5, 3) + 0.1j*npr.randn(5, 3) check_grads(fun)(A) check_grads(d_fun)(A)
def test_inv_3d(): fun = lambda x: np.linalg.inv(x) D = 4 mat = npr.randn(D, D, D) + 5*np.eye(D) check_grads(fun)(mat) mat = npr.randn(D, D, D, D) + 5*np.eye(D) check_grads(fun)(mat)
def test_mutating_outgrad(): def fun(a): b = a + 1.0 c = b + 1.5 d = a + b e = d + c return e A = npr.randn(5) check_grads(fun)(A)
def test_mutating_outgrad_from_indexing(): def fun(a): b = a + 1.0 c = b[0] + 1.5 d = a + b e = d + c return e A = npr.randn(5) check_grads(fun)(A)
def test_power_arg0(): # the +1.'s here are to avoid regimes where numerical diffs fail make_fun = lambda y: lambda x: np.power(x, y) fun = make_fun(npr.randn()**2 + 1.) check_grads(fun)(npr.rand()**2 + 1.) # test y == 0. as a special case, c.f. #116 fun = make_fun(0.) assert grad(fun)(0.) == 0. assert grad(grad(fun))(0.) == 0.
def test_pdmatrix_custom_autodiff(self): x_vec = np.random.random(6) x_mat = paragami.psdmatrix_patterns._unvectorize_ld_matrix(x_vec) check_grads( paragami.psdmatrix_patterns._vectorize_ld_matrix, modes=['fwd', 'rev'], order=3)(x_mat) check_grads( paragami.psdmatrix_patterns._unvectorize_ld_matrix, modes=['fwd', 'rev'], order=3)(x_vec)
def test_power_arg0(): # the +1.'s here are to avoid regimes where numerical diffs fail make_fun = lambda y: lambda x: np.power(x, y) fun = make_fun(npr.randn()**2 + 1.) check_grads(fun)(npr.rand()**2 + 1.) # test y == 0. as a special case, c.f. #116 fun = make_fun(0.) assert grad(fun)(0.) == 0. assert grad(grad(fun))(0.) == 0.
def test_jacobian_higher_order(): fun = lambda x: np.sin(np.outer(x, x)) + np.cos(np.dot(x, x)) assert jacobian(fun)(npr.randn(2)).shape == (2, 2, 2) assert jacobian(jacobian(fun))(npr.randn(2)).shape == (2, 2, 2, 2) # assert jacobian(jacobian(jacobian(fun)))(npr.randn(2)).shape == (2,2,2,2,2) check_grads(lambda x: np.sum(np.sin(jacobian(fun)(x))))(npr.randn(2)) check_grads(lambda x: np.sum(np.sin(jacobian(jacobian(fun))(x))))( npr.randn(2))
def test_svd_tall_2d(): def fun(x): u, s, v = np.linalg.svd(x, full_matrices=False) return tuple((u, s, v)) return grad(fun)(x) m = 5 n = 3 mat = npr.randn(m, n) check_grads(fun)(mat)
def test_mutating_outgrad_from_indexing(): def fun(a): b = a + 1.0 c = b[0] + 1.5 d = a + b e = d + c return e A = npr.randn(5) check_grads(fun)(A)
def test_svd_only_s_2d(): def fun(x): s = np.linalg.svd(x, full_matrices=False, compute_uv=False) return s return grad(fun)(x) m = 5 n = 3 mat = npr.randn(m, n) check_grads(fun)(mat)
def test_complex_separate_real_and_imaginary(): def fun(a): r, i = np.real(a), np.imag(a) a = np.abs(r)**1.4 + np.abs(i)**1.3 return np.sum(np.sin(a)) d_fun = lambda x: grad(fun)(x) A = npr.randn(5, 3) + 0.1j * npr.randn(5, 3) check_grads(fun)(A) check_grads(d_fun)(A)
def test_mutating_outgrad(): def fun(a): b = a + 1.0 c = b + 1.5 d = a + b e = d + c return e A = npr.randn(5) check_grads(fun)(A)
def test_r_slicing(): with warnings.catch_warnings(record=True) as w: c = npr.randn(10) def fun(x): b = np.r_[x, c, 1:10] return b A = npr.randn(10) check_grads(fun)(A)
def test_c_mixed(): with warnings.catch_warnings(record=True) as w: c = npr.randn(3, 2) def fun(x): b = np.c_[x, c, x] return b A = npr.randn(3, 2) check_grads(fun)(A)
def test_r_node_and_const(): with warnings.catch_warnings(record=True) as w: c = npr.randn(3, 2) def fun(x): b = np.r_[x, c] return b A = npr.randn(3, 2) check_grads(fun)(A)
def test_r_no_relation(): with warnings.catch_warnings(record=True) as w: c = npr.randn(3, 2) def fun(x): b = np.r_[c] return b A = npr.randn(3, 2) check_grads(fun)(A)
def test_r_double(): with warnings.catch_warnings(record=True) as w: def fun(x): c = npr.randn(3, 2) b = np.r_[x, x] return b A = npr.randn(3, 2) check_grads(fun)(A)
def test_r_basic(): with warnings.catch_warnings(record=True) as w: def fun(x): c = cpr.randn(3, 2) b = cp.r_[x] return b A = cpr.randn(3, 2) check_grads(fun)(A)
def test_svd_only_s_3d_complex(): def fun(x): s = np.linalg.svd(x, full_matrices=False, compute_uv=False) return s k = 4 m = 5 n = 3 mat = npr.randn(k, m, n) + 1j * npr.randn(k, m, n) check_grads(fun)(mat)
def test_svd_only_s_2d(): def fun(x): s = np.linalg.svd(x, full_matrices=False, compute_uv=False) return s return grad(fun)(x) m = 5 n = 3 mat = npr.randn(m, n) check_grads(fun)(mat)
def test_svd_tall_3d_complex(): def fun(x): u, s, v = np.linalg.svd(x, full_matrices=False) return tuple((np.abs(u), s, np.abs(v))) k = 4 m = 5 n = 3 mat = npr.randn(k, m, n) + 1j * npr.randn(k, m, n) check_grads(fun)(mat)
def test_svd_square_3d(): def fun(x): u, s, v = np.linalg.svd(x, full_matrices=False) return tuple((u, s, v)) k = 3 m = 4 n = 4 mat = npr.randn(k, m, n) check_grads(fun)(mat)
def test_reshape_method_nolist(): # The reshape can be called in two different ways: # like A.reshape((5,4)) or A.reshape(5,4). # This test checks that we support the second way. A = npr.randn(5, 6, 4) def fun(x): return x.reshape(5 * 4, 6) check_grads(fun)(A)
def test_blocks_to_banded_grad(T=25, D=4): """ Test blocks_to_banded gradient """ J_diag, J_lower_diag, J_full = make_block_tridiag(T, D) J_diag = np.tile(J_diag[None, :, :], (T, 1, 1)) J_lower_diag = np.tile(J_lower_diag[None, :, :], (T-1, 1, 1)) check_grads(blocks_to_bands, argnum=0, modes=['rev'], order=1)(J_diag, J_lower_diag) check_grads(blocks_to_bands, argnum=1, modes=['rev'], order=1)(J_diag, J_lower_diag)
def test_transpose_banded_grad(T=25, D=4): """ Test transpose_banded gradient """ J_diag, J_lower_diag, J_full = make_block_tridiag(T, D) J_diag = np.tile(J_diag[None, :, :], (T, 1, 1)) J_lower_diag = np.tile(J_lower_diag[None, :, :], (T-1, 1, 1)) J_banded = blocks_to_bands(J_diag, J_lower_diag, lower=True) check_grads(transpose_banded, argnum=1, modes=['rev'], order=1)((2*D-1, 0), J_banded)
def test_displace_gradients(self): args, coeffs, ke, u = get_mini_problem() var_names = ['penal', 'forces', 'freedofs', 'fixdofs'] [penal, forces, freedofs, fixdofs] = [args[k] for k in var_names] pos_args = (forces, freedofs, fixdofs) kwargs = dict(penal=args['penal'], e_min=args['young_min'], e_0=args['young']) check_grads( lambda x: topo_physics.displace(x, ke, *pos_args, **kwargs), modes=['rev'])(coeffs)
def test_diagonal(): def fun(D): return np.diagonal(D, axis1=-1, axis2=-2) D = np.random.randn(4, 4) A = np.make_diagonal(D, axis1=-1, axis2=-2) check_grads(fun)(D) D = np.random.randn(3, 4, 4) A = np.make_diagonal(D, axis1=-1, axis2=-2) check_grads(fun)(D)
def test_svd_wide_3d(): def fun(x): u, s, v = np.linalg.svd(x, full_matrices=False) return tuple((u, s, v)) return grad(fun)(x) k = 4 m = 3 n = 5 mat = npr.randn(k, m, n) check_grads(fun)(mat)
def test_slogdet(self): def fun(x): sign, logdet = np.linalg.slogdet(x) return logdet D = 6 mat = npr.randn(D, D) mat[0, 1] = mat[1, 0] + 1 # Make sure the matrix is not symmetric check_grads(fun)(mat) check_grads(fun)(-mat)
def test_value_and_grad(): fun = lambda x: np.sum(np.sin(x)**2) dfun = grad(fun) dfun_both = value_and_grad(fun) x = npr.randn(5) assert not isbox(dfun_both(x)[0]) check_equivalent(fun(x), dfun_both(x)[0]) check_equivalent(dfun(x), dfun_both(x)[1]) def fun2(x): return dfun_both(x)[0] check_grads(fun2)(x)
def test_complex_mutating_outgrad_from_indexing(): def fun(a): b = a + 1.0j c = b[0] + 1.5 d = a + b e = d + c return np.sum(np.sin(np.real(e))) A = npr.randn(5) check_grads(fun)(A) d_fun = lambda x : grad(fun)(x) check_grads(d_fun)(A)
def test_complex_mutating_outgrad_from_indexing(): def fun(a): b = a + 1.0j c = b[0] + 1.5 d = a + b e = d + c return np.sum(np.sin(np.real(e))) A = npr.randn(5) check_grads(fun)(A) d_fun = lambda x: grad(fun)(x) check_grads(d_fun)(A)
def test_unimplemented_falseyness(): @contextmanager def remove_grad_definitions(fun): vjpmaker = primitive_vjps.pop(fun, None) yield if vjpmaker: primitive_vjps[fun] = vjpmaker with remove_grad_definitions(np.iscomplex): fun = lambda x: np.real(x**2 if np.iscomplex(x) else np.sum(x)) check_grads(fun)(5.) check_grads(fun)(2. + 1j)
def test_svd_square_3d(): def fun(x): u, s, v = np.linalg.svd(x, full_matrices=False) return tuple((u, s, v)) return grad(fun)(x) k = 3 m = 4 n = 4 mat = npr.randn(k, m, n) check_grads(fun)(mat)
def test_toposim_gradients(self): # is the entire simulation differentiable? args, coeffs, ke, u = get_mini_problem() args['opt_steps'] = 3 np.random.seed(0) try: original_rtol = autograd.test_util.RTOL autograd.test_util.RTOL = 1e-5 check_grads(lambda x: topo_physics.run_toposim(x, args), modes=['rev'])(coeffs) finally: autograd.test_util.RTOL = original_rtol
def test_unimplemented_falseyness(): @contextmanager def remove_grad_definitions(fun): vjpmaker = primitive_vjps.pop(fun, None) yield if vjpmaker: primitive_vjps[fun] = vjpmaker with remove_grad_definitions(np.iscomplex): fun = lambda x: np.real(x**2 if np.iscomplex(x) else np.sum(x)) check_grads(fun)(5.) check_grads(fun)(2. + 1j)
def test_lds_sample_grad(T=10, D=2): """ Test lds_sample gradient """ As, bs, Qi_sqrts, ms, Ri_sqrts = make_lds_parameters(T, D) z = npr.randn(T, D) check_grads(lds_sample, argnum=0, modes=['rev'], order=1)(As, bs, Qi_sqrts, ms, Ri_sqrts, z=z) check_grads(lds_sample, argnum=1, modes=['rev'], order=1)(As, bs, Qi_sqrts, ms, Ri_sqrts, z=z) check_grads(lds_sample, argnum=2, modes=['rev'], order=1)(As, bs, Qi_sqrts, ms, Ri_sqrts, z=z) check_grads(lds_sample, argnum=3, modes=['rev'], order=1)(As, bs, Qi_sqrts, ms, Ri_sqrts, z=z) check_grads(lds_sample, argnum=4, modes=['rev'], order=1)(As, bs, Qi_sqrts, ms, Ri_sqrts, z=z)
def main_func_train(inputs, targets): #targets = np.array([1, 1, 0, 1]) # Build a function that returns gradients of training loss using autograd. training_gradient_fun = grad(training_loss) # Check the gradients numerically, just to be safe. weights = np.array([0.0, 0.0, 0.0]) check_grads(training_loss, modes=['rev'])(weights) # Optimize weights using gradient descent. print("Initial loss:", training_loss(weights))
def test_hess_vector_prod(): npr.seed(1) randv = npr.randn(10) def fun(x): return np.sin(np.dot(x, randv)) df = grad(fun) def vector_product(x, v): return np.sin(np.dot(v, df(x))) ddf = grad(vector_product) A = npr.randn(10) B = npr.randn(10) check_grads(fun)(A) check_grads(vector_product)(A, B)
def test_make_dict(): def fun(x): return ag_dict([('a', x)], b=x) check_grads(fun, modes=['rev'])(1.0) def fun(x): return ag_dict({'a': x}) check_grads(fun, modes=['rev'])(1.0) # check some other forms of the constructor ag_dict() ag_dict(()) ag_dict({})
def test_deprecated_defvjp_is_zero_wrapper(): from autograd.core import primitive @primitive def new_mul(x, y): return 0 * x * y with warnings.catch_warnings(record=True) as w: new_mul.defvjp_is_zero([0, 1]) def fun(x, y): return new_mul(x, y) mat1 = npr.randn(2, 2) mat2 = npr.randn(2, 2) with warnings.catch_warnings(record=True) as w: check_grads(fun, modes=['rev'])(mat1, mat2)
def test_deprecated_defvjp_wrapper(): from autograd.core import primitive @primitive def new_mul(x, y): return x * y with warnings.catch_warnings(record=True) as w: new_mul.defvjp(lambda g, ans, vs, gvs, x, y : y * g) new_mul.defvjp(lambda g, ans, vs, gvs, x, y : x * g, argnum=1) def fun(x, y): return new_mul(x, y) mat1 = npr.randn(2, 2) mat2 = npr.randn(2, 2) check_grads(fun, modes=['rev'])(mat1, mat2)
def test_third_derivative_other_args2(): fun = lambda x, y : np.sin(np.sin(x) + np.sin(y)) df = grad(fun, 1) ddf = grad(fun) dddf = grad(fun, 1) check_grads(fun)(npr.randn(), npr.randn()) check_grads(df)(npr.randn(), npr.randn()) check_grads(ddf)(npr.randn(), npr.randn()) check_grads(dddf)(npr.randn(), npr.randn())
def test_third_derivative(): fun = lambda x : np.sin(np.sin(x) + np.sin(x)) df = grad(fun) ddf = grad(fun) dddf = grad(fun) check_grads(fun)(npr.randn()) check_grads(df)(npr.rand()) check_grads(ddf)(npr.rand()) check_grads(dddf)(npr.rand())
def test_check_vjp_1st_order_fail(): @primitive def foo(x): return x * 2.0 defvjp(foo, lambda ans, x : lambda g: g * 2.001) assert_raises_regexp(AssertionError, "\(VJP\) check of foo failed", lambda: check_grads(foo, modes=['rev'])(1.0))
def test_grads(): def fun(input_tuple): A = np.sum(np.sin(input_tuple[0])) B = np.sum(np.cos(input_tuple[1])) return A + B def d_fun(input_tuple): g = grad(fun)(input_tuple) A = np.sum(g[0]) B = np.sum(np.sin(g[0])) C = np.sum(np.sin(g[1])) return A + B + C input_tuple = (npr.randn(5, 6), npr.randn(4, 3), npr.randn(2, 4)) check_grads(fun)(input_tuple) check_grads(d_fun)(input_tuple)
def test_grads(): def fun(input_dict): A = np.sum(np.sin(input_dict['item_1'])) B = np.sum(np.cos(input_dict['item_2'])) return A + B def d_fun(input_dict): g = grad(fun)(input_dict) A = np.sum(g['item_1']) B = np.sum(np.sin(g['item_1'])) C = np.sum(np.sin(g['item_2'])) return A + B + C input_dict = {'item_1' : npr.randn(5, 6), 'item_2' : npr.randn(4, 3), 'item_X' : npr.randn(2, 4)} check_grads(fun)(input_dict) check_grads(d_fun)(input_dict)
def test_grads(): def fun(input_list): A = np.sum(np.sin(input_list[0])) B = np.sum(np.cos(input_list[1])) return A + B def d_fun(input_list): g = grad(fun)(input_list) A = np.sum(g[0]) B = np.sum(np.sin(g[0])) C = np.sum(np.sin(g[1])) return A + B + C input_list = [npr.randn(5, 6), npr.randn(4, 3), npr.randn(2, 4)] check_grads(fun)(input_list) check_grads(d_fun)(input_list)
def test_iter(): def fun(input_dict): A = 0. B = 0. for i, k in enumerate(sorted(input_dict)): A = A + np.sum(np.sin(input_dict[k])) * (i + 1.0) B = B + np.sum(np.cos(input_dict[k])) return A + B def d_fun(input_dict): g = grad(fun)(input_dict) A = np.sum(g['item_1']) B = np.sum(np.sin(g['item_1'])) C = np.sum(np.sin(g['item_2'])) return A + B + C input_dict = {'item_1' : npr.randn(5, 6), 'item_2' : npr.randn(4, 3), 'item_X' : npr.randn(2, 4)} check_grads(fun)(input_dict) check_grads(d_fun)(input_dict)