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)
