def symmetric_parafac_power_iteration(tensor,
rank,
n_repeat=10,
n_iteration=10,
verbose=False):
"""Symmetric CP Decomposition via Robust Symmetric Tensor Power Iteration
Parameters
----------
tensor : tl.tensor
input tensor to decompose, must be symmetric of shape (size, )*order
rank : int
rank of the decomposition (number of rank-1 components)
n_repeat : int, default is 10
number of initializations to be tried
n_iterations : int, default is 10
number of power iterations
verbose : bool
level of verbosity
Returns
-------
(weights, factor)
weights : 1-D tl.tensor of length `rank`
contains the eigenvalue of each eigenvector
factor : 2-D tl.tensor of shape (size, rank)
each column corresponds to one eigenvector
"""
rank = validate_cp_rank(tl.shape(tensor), rank=rank)
order = tl.ndim(tensor)
size = tl.shape(tensor)[0]
if not tl.shape(tensor) == (size, ) * order:
raise ValueError(
'The input tensor does not have the same size along each mode.')
factor = []
weigths = []
for _ in range(rank):
eigenval, eigenvec, deflated = symmetric_power_iteration(
tensor,
n_repeat=n_repeat,
n_iteration=n_iteration,
verbose=verbose)
factor.append(eigenvec)
weigths.append(eigenval)
tensor = deflated
factor = tl.stack(factor, axis=1)
weigths = tl.stack(weigths)
return weigths, factor
def parafac_power_iteration(tensor,
rank,
n_repeat=10,
n_iteration=10,
verbose=0):
"""CP Decomposition via Robust Tensor Power Iteration
Parameters
----------
tensor : tl.tensor
input tensor to decompose
rank : int
rank of the decomposition (number of rank-1 components)
n_repeat : int, default is 10
number of initializations to be tried
n_iteration : int, default is 10
number of power iterations
verbose : bool
level of verbosity
Returns
-------
(weights, factors)
weights : 1-D tl.tensor of length `rank`
contains the eigenvalue of each eigenvector
factors : list of 2-D tl.tensor of shape (size, rank)
Each column of each factor corresponds to one eigenvector
"""
rank = validate_cp_rank(tl.shape(tensor), rank=rank)
order = tl.ndim(tensor)
factors = []
weigths = []
for _ in range(rank):
eigenval, eigenvec, deflated = power_iteration(tensor,
n_repeat=n_repeat,
n_iteration=n_iteration,
verbose=verbose)
factors.append(eigenvec)
weigths.append(eigenval)
tensor = deflated
factors = [tl.stack([f[i] for f in factors], axis=1) for i in range(order)]
weigths = tl.stack(weigths)
return weigths, factors
def parafac(tensor,
rank,
n_iter_max=100,
init='svd',
svd='numpy_svd',
normalize_factors=False,
tol=1e-8,
orthogonalise=False,
random_state=None,
verbose=False,
return_errors=False,
non_negative=False,
mask=None):
"""CANDECOMP/PARAFAC decomposition via alternating least squares (ALS)
Computes a rank-`rank` decomposition of `tensor` [1]_ such that,
``tensor = [|weights; factors[0], ..., factors[-1] |]``.
Parameters
----------
tensor : ndarray
rank : int
Number of components.
n_iter_max : int
Maximum number of iteration
init : {'svd', 'random'}, optional
Type of factor matrix initialization. See `initialize_factors`.
svd : str, default is 'numpy_svd'
function to use to compute the SVD, acceptable values in tensorly.SVD_FUNS
normalize_factors : if True, aggregate the weights of each factor in a 1D-tensor
of shape (rank, ), which will contain the norms of the factors
tol : float, optional
(Default: 1e-6) Relative reconstruction error tolerance. The
algorithm is considered to have found the global minimum when the
reconstruction error is less than `tol`.
random_state : {None, int, np.random.RandomState}
verbose : int, optional
Level of verbosity
return_errors : bool, optional
Activate return of iteration errors
non_negative : bool, optional
Perform non_negative PARAFAC. See :func:`non_negative_parafac`.
mask : ndarray
array of booleans with the same shape as ``tensor`` should be 0 where
the values are missing and 1 everywhere else. Note: if tensor is
sparse, then mask should also be sparse with a fill value of 1 (or
True). Allows for missing values [2]_
Returns
-------
KruskalTensor : (weight, factors)
* weights : 1D array of shape (rank, )
all ones if normalize_factors is False (default),
weights of the (normalized) factors otherwise
* factors : List of factors of the CP decomposition element `i` is of shape
(tensor.shape[i], rank)
errors : list
A list of reconstruction errors at each iteration of the algorithms.
References
----------
.. [1] T.G.Kolda and B.W.Bader, "Tensor Decompositions and Applications",
SIAM REVIEW, vol. 51, n. 3, pp. 455-500, 2009.
.. [2] Tomasi, Giorgio, and Rasmus Bro. "PARAFAC and missing values."
Chemometrics and Intelligent Laboratory Systems 75.2 (2005): 163-180.
"""
epsilon = 10e-12
if orthogonalise and not isinstance(orthogonalise, int):
orthogonalise = n_iter_max
factors = initialize_factors(tensor,
rank,
init=init,
svd=svd,
random_state=random_state,
non_negative=non_negative)
rec_errors = []
norm_tensor = tl.norm(tensor, 2)
weights = tl.ones(rank, **tl.context(tensor))
for iteration in range(n_iter_max):
if orthogonalise and iteration <= orthogonalise:
factor = [tl.qr(factor)[0] for factor in factors]
if verbose:
print("Starting iteration", iteration)
for mode in range(tl.ndim(tensor)):
if verbose:
print("Mode", mode, "of", tl.ndim(tensor))
if non_negative:
accum = 1
# khatri_rao(factors).tl.dot(khatri_rao(factors))
# simplifies to multiplications
sub_indices = [i for i in range(len(factors)) if i != mode]
for i, e in enumerate(sub_indices):
if i:
accum *= tl.dot(tl.transpose(factors[e]), factors[e])
else:
accum = tl.dot(tl.transpose(factors[e]), factors[e])
pseudo_inverse = tl.tensor(np.ones((rank, rank)),
**tl.context(tensor))
for i, factor in enumerate(factors):
if i != mode:
pseudo_inverse = pseudo_inverse * tl.dot(
tl.conj(tl.transpose(factor)), factor)
if mask is not None:
tensor = tensor * mask + tl.kruskal_to_tensor(factors,
mask=1 - mask)
mttkrp = unfolding_dot_khatri_rao(tensor, (weights, factors), mode)
if non_negative:
numerator = tl.clip(mttkrp, a_min=epsilon, a_max=None)
denominator = tl.dot(factors[mode], accum)
denominator = tl.clip(denominator, a_min=epsilon, a_max=None)
factor = factors[mode] * numerator / denominator
else:
factor = tl.transpose(
tl.solve(tl.conj(tl.transpose(pseudo_inverse)),
tl.transpose(mttkrp)))
if normalize_factors:
factor_norm = tl.norm(factor, axis=0)
weights *= factor_norm
positive_factor_norms = tl.where(
factor_norm == 0,
tl.ones(tl.shape(factor_norm), **tl.context(factors[0])),
factor_norm)
factor = factor / positive_factor_norms
factors[mode] = factor
if tol:
# ||tensor - rec||^2 = ||tensor||^2 + ||rec||^2 - 2*<tensor, rec>
# This is ||kruskal_to_tensor(factors)||^2
factors_norm = tl.sum(
tl.prod(
tl.stack([tl.dot(tl.transpose(f), f) for f in factors], 0),
0))
# mttkrp and factor for the last mode. This is equivalent to the
# inner product <tensor, factorization>
iprod = tl.sum(mttkrp * factor)
rec_error = tl.sqrt(
tl.abs(norm_tensor**2 + factors_norm -
2 * iprod)) / norm_tensor
rec_errors.append(rec_error)
if iteration >= 1:
if verbose:
print('reconstruction error={}, variation={}.'.format(
rec_errors[-1], rec_errors[-2] - rec_errors[-1]))
if tol and abs(rec_errors[-2] - rec_errors[-1]) < tol:
if verbose:
print('converged in {} iterations.'.format(iteration))
break
else:
if verbose:
print('reconstruction error={}'.format(rec_errors[-1]))
kruskal_tensor = KruskalTensor((weights, factors))
if return_errors:
return kruskal_tensor, rec_errors
else:
return kruskal_tensor
def parafac(tensor,
rank,
n_iter_max=100,
init='svd',
svd='numpy_svd',
tol=1e-8,
orthogonalise=False,
random_state=None,
verbose=False,
return_errors=False,
non_negative=False):
"""CANDECOMP/PARAFAC decomposition via alternating least squares (ALS)
Computes a rank-`rank` decomposition of `tensor` [1]_ such that,
``tensor = [| factors[0], ..., factors[-1] |]``.
Parameters
----------
tensor : ndarray
rank : int
Number of components.
n_iter_max : int
Maximum number of iteration
init : {'svd', 'random'}, optional
Type of factor matrix initialization. See `initialize_factors`.
svd : str, default is 'numpy_svd'
function to use to compute the SVD, acceptable values in tensorly.SVD_FUNS
tol : float, optional
(Default: 1e-6) Relative reconstruction error tolerance. The
algorithm is considered to have found the global minimum when the
reconstruction error is less than `tol`.
random_state : {None, int, np.random.RandomState}
verbose : int, optional
Level of verbosity
return_errors : bool, optional
Activate return of iteration errors
non_negative : bool, optional
Perform non_negative PARAFAC. See :func:`non_negative_parafac`.
Returns
-------
factors : ndarray list
List of factors of the CP decomposition element `i` is of shape
(tensor.shape[i], rank)
errors : list
A list of reconstruction errors at each iteration of the algorithms.
References
----------
.. [1] tl.G.Kolda and B.W.Bader, "Tensor Decompositions and Applications",
SIAM REVIEW, vol. 51, n. 3, pp. 455-500, 2009.
"""
epsilon = 10e-12
if orthogonalise and not isinstance(orthogonalise, int):
orthogonalise = n_iter_max
factors = initialize_factors(tensor,
rank,
init=init,
svd=svd,
random_state=random_state,
non_negative=non_negative)
rec_errors = []
norm_tensor = tl.norm(tensor, 2)
for iteration in range(n_iter_max):
if orthogonalise and iteration <= orthogonalise:
factor = [tl.qr(factor)[0] for factor in factors]
if verbose:
print("Starting iteration", iteration)
for mode in range(tl.ndim(tensor)):
if verbose:
print("Mode", mode, "of", tl.ndim(tensor))
if non_negative:
accum = 1
# khatri_rao(factors).tl.dot(khatri_rao(factors))
# simplifies to multiplications
sub_indices = [i for i in range(len(factors)) if i != mode]
for i, e in enumerate(sub_indices):
if i:
accum *= tl.dot(tl.transpose(factors[e]), factors[e])
else:
accum = tl.dot(tl.transpose(factors[e]), factors[e])
pseudo_inverse = tl.tensor(np.ones((rank, rank)),
**tl.context(tensor))
for i, factor in enumerate(factors):
if i != mode:
pseudo_inverse = pseudo_inverse * tl.dot(
tl.conj(tl.transpose(factor)), factor)
#factor = tl.dot(unfold(tensor, mode), khatri_rao(factors, skip_matrix=mode).conj())
mttkrp = tl.tenalg.unfolding_dot_khatri_rao(tensor, factors, mode)
if non_negative:
numerator = tl.clip(mttkrp, a_min=epsilon, a_max=None)
denominator = tl.dot(factors[mode], accum)
denominator = tl.clip(denominator, a_min=epsilon, a_max=None)
factor = factors[mode] * numerator / denominator
else:
factor = tl.transpose(
tl.solve(tl.conj(tl.transpose(pseudo_inverse)),
tl.transpose(mttkrp)))
factors[mode] = factor
if tol:
# ||tensor - rec||^2 = ||tensor||^2 + ||rec||^2 - 2*<tensor, rec>
# This is ||kruskal_to_tensor(factors)||^2
factors_norm = tl.sum(
tl.prod(
tl.stack([tl.dot(tl.transpose(f), f) for f in factors], 0),
0))
# mttkrp and factor for the last mode. This is equivalent to the
# inner product <tensor, factorization>
iprod = tl.sum(mttkrp * factor)
rec_error = tl.sqrt(
tl.abs(norm_tensor**2 + factors_norm -
2 * iprod)) / norm_tensor
rec_errors.append(rec_error)
if iteration >= 1:
if verbose:
print('reconstruction error={}, variation={}.'.format(
rec_errors[-1], rec_errors[-2] - rec_errors[-1]))
if tol and abs(rec_errors[-2] - rec_errors[-1]) < tol:
if verbose:
print('converged in {} iterations.'.format(iteration))
break
else:
if verbose:
print('reconstruction error={}'.format(rec_errors[-1]))
if return_errors:
return factors, rec_errors
else:
return factors
