def test_tape_safe(self): diagonals = [ variables_module.Variable([3., 6., 2.]), variables_module.Variable([2., 4., 2.]), variables_module.Variable([5., 1., 2.]) ] operator = linalg_lib.LinearOperatorTridiag( diagonals, diagonals_format='sequence') # Skip the diagonal part and trace since this only dependent on the # middle variable. We test this below. self.check_tape_safe(operator, skip_options=['diag_part', 'trace']) diagonals = [[3., 6., 2.], variables_module.Variable([2., 4., 2.]), [5., 1., 2.]] operator = linalg_lib.LinearOperatorTridiag( diagonals, diagonals_format='sequence')
def test_convert_variables_to_tensors(self): diag = variables_module.Variable([[3., 6., 2.], [2., 4., 2.], [5., 1., 2.]]) operator = linalg_lib.LinearOperatorTridiag(diag, diagonals_format='compact') with self.cached_session() as sess: sess.run([diag.initializer]) self.check_convert_variables_to_tensors(operator)
def build_operator_and_matrix( self, build_info, dtype, use_placeholder, ensure_self_adjoint_and_pd=False, diagonals_format='sequence'): shape = list(build_info.shape) # Ensure that diagonal has large enough values. If we generate a # self adjoint PD matrix, then the diagonal will be dominant guaranteeing # positive definitess. diag = linear_operator_test_util.random_sign_uniform( shape[:-1], minval=4., maxval=6., dtype=dtype) # We'll truncate these depending on the format subdiag = linear_operator_test_util.random_sign_uniform( shape[:-1], minval=1., maxval=2., dtype=dtype) if ensure_self_adjoint_and_pd: # Abs on complex64 will result in a float32, so we cast back up. diag = math_ops.cast(math_ops.abs(diag), dtype=dtype) # The first element of subdiag is ignored. We'll add a dummy element # to superdiag to pad it. superdiag = math_ops.conj(subdiag) superdiag = manip_ops.roll(superdiag, shift=-1, axis=-1) else: superdiag = linear_operator_test_util.random_sign_uniform( shape[:-1], minval=1., maxval=2., dtype=dtype) matrix_diagonals = array_ops.stack( [superdiag, diag, subdiag], axis=-2) matrix = gen_array_ops.matrix_diag_v3( matrix_diagonals, k=(-1, 1), num_rows=-1, num_cols=-1, align='LEFT_RIGHT', padding_value=0.) if diagonals_format == 'sequence': diagonals = [superdiag, diag, subdiag] elif diagonals_format == 'compact': diagonals = array_ops.stack([superdiag, diag, subdiag], axis=-2) elif diagonals_format == 'matrix': diagonals = matrix lin_op_diagonals = diagonals if use_placeholder: if diagonals_format == 'sequence': lin_op_diagonals = [array_ops.placeholder_with_default( d, shape=None) for d in lin_op_diagonals] else: lin_op_diagonals = array_ops.placeholder_with_default( lin_op_diagonals, shape=None) operator = linalg_lib.LinearOperatorTridiag( diagonals=lin_op_diagonals, diagonals_format=diagonals_format, is_self_adjoint=True if ensure_self_adjoint_and_pd else None, is_positive_definite=True if ensure_self_adjoint_and_pd else None) return operator, matrix
def test_tape_safe(self): matrix = variables_module.Variable([[3., 2., 0.], [1., 6., 4.], [0., 2, 2]]) operator = linalg_lib.LinearOperatorTridiag(matrix, diagonals_format='matrix') self.check_tape_safe(operator)
def test_tape_safe(self): diag = variables_module.Variable([[3., 6., 2.], [2., 4., 2.], [5., 1., 2.]]) operator = linalg_lib.LinearOperatorTridiag(diag, diagonals_format='compact') self.check_tape_safe(operator)