def matrix_pair(self, rng, size, size_inner):
left_factor_matrix = rng.standard_normal((size, size_inner))
right_factor_matrix = rng.standard_normal((size_inner, size))
square_matrix = rng.standard_normal((size, size))
return (
matrices.SquareLowRankUpdateMatrix(
matrices.DenseRectangularMatrix(left_factor_matrix),
matrices.DenseRectangularMatrix(right_factor_matrix),
matrices.DenseSquareMatrix(square_matrix),
),
square_matrix + left_factor_matrix @ right_factor_matrix,
)
def __init__(self):
matrix_pairs = {}
rng = np.random.RandomState(SEED)
for outer_dim in SIZES:
inner_dim = max(1, outer_dim // 2)
left_factor_matrix = rng.standard_normal((outer_dim, inner_dim))
right_factor_matrix = rng.standard_normal((inner_dim, outer_dim))
square_matrix = rng.standard_normal((outer_dim, outer_dim))
matrix_pairs[(inner_dim, outer_dim)] = (
matrices.SquareLowRankUpdateMatrix(
matrices.DenseRectangularMatrix(left_factor_matrix),
matrices.DenseRectangularMatrix(right_factor_matrix),
matrices.DenseSquareMatrix(square_matrix)),
square_matrix + left_factor_matrix @ right_factor_matrix)
super().__init__(matrix_pairs, rng)
def __init__(self):
matrix_pairs = {}
rng = np.random.RandomState(SEED)
for outer_dim in SIZES:
for inner_dim in [max(1, outer_dim // 2), max(1, outer_dim - 1)]:
factor_matrix = rng.standard_normal((outer_dim, inner_dim))
inner_pos_def_matrix = rng.standard_normal(
(inner_dim, inner_dim))
inner_pos_def_matrix = (
inner_pos_def_matrix @ inner_pos_def_matrix.T)
pos_def_matrix = rng.standard_normal((outer_dim, outer_dim))
pos_def_matrix = pos_def_matrix @ pos_def_matrix.T
matrix_pairs[(inner_dim, outer_dim)] = (
matrices.PositiveDefiniteLowRankUpdateMatrix(
matrices.DenseRectangularMatrix(factor_matrix),
matrices.DensePositiveDefiniteMatrix(pos_def_matrix),
matrices.DensePositiveDefiniteMatrix(
inner_pos_def_matrix)), pos_def_matrix +
factor_matrix @ (inner_pos_def_matrix @ factor_matrix.T))
if AUTOGRAD_AVAILABLE:
def param_func(param, matrix):
return (matrix.pos_def_matrix.array +
param @ matrix.inner_pos_def_matrix @ param.T)
def get_param(matrix):
return matrix.factor_matrix.array
else:
param_func, get_param = None, None
super().__init__(matrix_pairs, get_param, param_func, rng)
def __init__(self):
matrix_pairs = {}
rng = np.random.RandomState(SEED)
for s0 in SIZES:
for s1 in SIZES:
if s0 != s1:
array = rng.standard_normal((s0, s1))
matrix_pairs[(s0, s1)] = (
matrices.DenseRectangularMatrix(array), array)
super().__init__(matrix_pairs, rng)
def matrix_pair(self, rng, size, size_inner):
factor_matrix = rng.standard_normal((size, size_inner))
inner_pos_def_matrix = rng.standard_normal((size_inner, size_inner))
inner_pos_def_matrix = inner_pos_def_matrix @ inner_pos_def_matrix.T
pos_def_matrix = rng.standard_normal((size, size))
pos_def_matrix = pos_def_matrix @ pos_def_matrix.T
return (
matrices.PositiveDefiniteLowRankUpdateMatrix(
matrices.DenseRectangularMatrix(factor_matrix),
matrices.DensePositiveDefiniteMatrix(pos_def_matrix),
matrices.DensePositiveDefiniteMatrix(inner_pos_def_matrix),
),
pos_def_matrix + factor_matrix @ (inner_pos_def_matrix @ factor_matrix.T),
)
def matrix_pair(self, rng, size, request):
n_terms, explicit = request.param
arrays = [
rng.standard_normal(
(size if t % 2 == 0 else 2 * size, 2 * size if t % 2 == 0 else size)
)
for t in range(n_terms)
]
matrices_ = [matrices.DenseRectangularMatrix(a) for a in arrays]
np_matrix = nla.multi_dot(arrays)
if explicit:
return matrices.MatrixProduct(matrices_), np_matrix
else:
return reduce(lambda a, b: a @ b, matrices_), np_matrix
def matrix_pair(self, rng, size, size_inner):
factor_matrix = rng.standard_normal((size, size_inner))
inner_symmetric_matrix = rng.standard_normal((size_inner, size_inner))
inner_symmetric_matrix = inner_symmetric_matrix + inner_symmetric_matrix.T
symmetric_matrix = rng.standard_normal((size, size))
symmetric_matrix = symmetric_matrix + symmetric_matrix.T
return (
matrices.SymmetricLowRankUpdateMatrix(
matrices.DenseRectangularMatrix(factor_matrix),
matrices.DenseSymmetricMatrix(symmetric_matrix),
matrices.DenseSymmetricMatrix(inner_symmetric_matrix),
),
symmetric_matrix
+ factor_matrix @ (inner_symmetric_matrix @ factor_matrix.T),
)
def __init__(self):
matrix_pairs = {}
rng = np.random.RandomState(SEED)
for outer_dim in SIZES:
for inner_dim in [max(1, outer_dim // 2), max(1, outer_dim - 1)]:
factor_matrix = rng.standard_normal((outer_dim, inner_dim))
inner_symmetric_matrix = rng.standard_normal(
(inner_dim, inner_dim))
inner_symmetric_matrix = (inner_symmetric_matrix +
inner_symmetric_matrix.T)
symmetric_matrix = rng.standard_normal((outer_dim, outer_dim))
symmetric_matrix = symmetric_matrix + symmetric_matrix.T
matrix_pairs[(inner_dim, outer_dim)] = (
matrices.SymmetricLowRankUpdateMatrix(
matrices.DenseRectangularMatrix(factor_matrix),
matrices.DenseSymmetricMatrix(symmetric_matrix),
matrices.DenseSymmetricMatrix(inner_symmetric_matrix)),
symmetric_matrix +
factor_matrix @ (inner_symmetric_matrix @ factor_matrix.T))
super().__init__(matrix_pairs, rng)
def __init__(self):
matrix_pairs = {}
rng = np.random.RandomState(SEED)
for s in SIZES:
for n_terms in [2, 4]:
for explicit in [True, False]:
arrays = [
rng.standard_normal((s if t % 2 == 0 else 2 * s,
2 * s if t % 2 == 0 else s))
for t in range(n_terms)
]
matrices_ = [
matrices.DenseRectangularMatrix(a) for a in arrays
]
if explicit:
matrix = matrices.MatrixProduct(matrices_)
else:
matrix = reduce(lambda a, b: a @ b, matrices_)
matrix_pairs[(s, n_terms,
explicit)] = (matrix, nla.multi_dot(arrays))
super().__init__(matrix_pairs, rng)
def matrix_pair(self, rng, shape_0, shape_1):
array = rng.standard_normal((shape_0, shape_1))
return matrices.DenseRectangularMatrix(array), array
