tensorly.decomposition.robust_pca

robust_pca(X, mask=None, tol=1e-06, reg_E=1, reg_J=1, mu_init=0.0001, mu_max=10000000000.0, learning_rate=1.1, n_iter_max=100, random_state=None, verbose=1)[source]

Robust Tensor PCA via ALM with support for missing values

Decomposes a tensor X into the sum of a low-rank component D and a sparse component E.
Parameters:

X : ndarray

tensor data of shape (n_samples, N1, …, NS)

mask : ndarray

array of booleans with the same shape as X should be zero where the values are missing and 1 everywhere else

tol : float

convergence value

reg_E : float, optional, default is 1

regularisation on the sparse part E

reg_J : float, optional, default is 1

regularisation on the low rank part D

mu_init : float, optional, default is 10e-5

initial value for mu

mu_max : float, optional, default is 10e9

maximal value for mu

learning_rate : float, optional, default is 1.1

percentage increase of mu at each iteration

n_iter_max : int, optional, default is 100

maximum number of iteration

random_state : None, int or RandomState, optional, default is None

verbose : int, default is 1

level of verbosity

Returns:

(D, E)

Robust decomposition of X

D : X-like array

low-rank part

E : X-like array

sparse error part

Notes

The problem we solve is, for an input tensor \tilde X:

\begin{equation*}
 \begin{aligned}
    & \min_{\{J_i\}, \tilde D, \tilde E} 
    & & \sum_{i=1}^N  \text{reg}_J \|J_i\|_* + \text{reg}_E \|E\|_1 \\
    & \text{subject to} 
    & & \tilde X  = \tilde A + \tilde E \\
    & & & A_{[i]} =  J_i,  \text{ for each } i \in \{1, 2, \cdots, N\}\\
 \end{aligned}
 \end{equation*}