def test_pos_def_matrix_param(self):
k = 2
mat = np.full(k**2, 0.2).reshape(k, k) + np.eye(k)
# not symmetric
bad_mat = copy.deepcopy(mat)
bad_mat[1, 0] += +1
vp = PosDefMatrixParam('test', k)
# Check setting.
vp_init = PosDefMatrixParam('test', k, val=mat)
np_test.assert_array_almost_equal(mat, vp_init.get())
self.assertRaises(ValueError, vp.set, bad_mat)
self.assertRaises(ValueError, vp.set, np.eye(k + 1))
vp.set(mat)
# Check size.
self.assertEqual(k, vp.size())
self.assertEqual(k * (k + 1) / 2, vp.free_size())
# Check getting and free parameters.
np_test.assert_array_almost_equal(mat, vp.get())
mat_free = vp.get_free()
vp.set(np.full((k, k), 0.))
vp.set_free(mat_free)
np_test.assert_array_almost_equal(mat, vp.get())
mat_vectorized = vp.get_vector()
vp.set(np.full((k, k), 0.))
vp.set_vector(mat_vectorized)
np_test.assert_array_almost_equal(mat, vp.get())
def test_free_grads(self):
k = 2
mat = np.full(k**2, 0.2).reshape(k, k) + np.eye(k)
lb = -0.1
ub = 5.2
val = 0.5 * (ub - lb) + lb
vec = np.linspace(lb, ub, k)
vp_scalar = ScalarParam('scalar', lb=lb - 0.1, ub=ub + 0.1)
vp_mat = PosDefMatrixParam('matrix', k)
vp_vec = VectorParam('vector', k, lb=lb - 0.1, ub=ub + 0.1)
vp_scalar.set(val)
vp_vec.set(vec)
vp_mat.set(mat)
mp = par_dict.ModelParamsDict()
mp.push_param(vp_scalar)
mp.push_param(vp_vec)
mp.push_param(vp_mat)
# To take advantage of the old quick_grad_check(), define scalar
# functions of each parameter. It would be nice to have an easy-to-use
# test for Jacobians.
def ScalarFun(val_free):
vp_scalar_ad = copy.deepcopy(vp_scalar)
vp_scalar_ad.set_free(val_free)
return vp_scalar_ad.get()
def VecFun(val_free):
vp_vec_ad = copy.deepcopy(vp_vec)
vp_vec_ad.set_free(val_free)
return np.linalg.norm(vp_vec_ad.get())
def MatFun(val_free):
vp_mat_ad = copy.deepcopy(vp_mat)
vp_mat_ad.set_free(val_free)
return np.linalg.norm(vp_mat_ad.get())
def ParamsFun(val_free):
mp_ad = copy.deepcopy(mp)
mp_ad.set_free(val_free)
return mp_ad['scalar'].get() + \
np.linalg.norm(mp_ad['vector'].get()) + \
np.linalg.norm(mp_ad['matrix'].get())
check_grads(ScalarFun, modes=['rev'], order=2)(vp_scalar.get_free())
check_grads(VecFun, modes=['rev'], order=2)(vp_vec.get_free())
check_grads(MatFun, modes=['rev'], order=2)(vp_mat.get_free())
check_grads(ParamsFun, modes=['rev'], order=2)(mp.get_free())
def test_LDMatrixParamDerivatives(self):
# Test the LD matrix extra carefully since we define our own
# autograd derivatives.
k = 2
mat = np.full(k**2, 0.2).reshape(k, k) + np.eye(k)
diag_lb = 0.5
vp = PosDefMatrixParam('test', k, diag_lb=diag_lb)
vp.set(mat)
mat_free = vp.get_free()
def MatFun(mat_free):
vp_ad = copy.deepcopy(vp)
vp_ad.set_free(mat_free)
return vp_ad.get()
MatFunJac = jacobian(MatFun)
MatFunHess = hessian(MatFun)
# Test the jacobian
eps = 1e-4
for ind in range(len(mat_free)):
mat_free_eps = copy.deepcopy(mat_free)
mat_free_eps[ind] += eps
num_grad = MatFun(mat_free_eps) - MatFun(mat_free)
np_test.assert_array_almost_equal(
num_grad,
eps * MatFunJac(mat_free)[:, :, ind])
# Test the hessian
eps = 1e-4
for ind1 in range(len(mat_free)):
for ind2 in range(len(mat_free)):
eps1_vec = np.zeros_like(mat_free)
eps2_vec = np.zeros_like(mat_free)
eps1_vec[ind1] = eps
eps2_vec[ind2] = eps
num_hess = MatFun(mat_free + eps1_vec + eps2_vec) - \
MatFun(mat_free + eps2_vec) - \
(MatFun(mat_free + eps1_vec) - MatFun(mat_free))
np_test.assert_array_almost_equal(
num_hess,
(eps**2) * MatFunHess(mat_free)[:, :, ind1, ind2])