Decomposition Models

Abstract type for the different decompositions.

Main interface for subtypes are the following functions. Required: array(D): how to construct the full array from the decomposition representation factors(D): a tuple of arrays, the decomposed factors Optional: getindex(D, i::Int) and getindex(D, I::Vararg{Int, N}): how to get the ith or Ith element of the reconstructed array. Defaults to getindex(array(D), x), but there is often a more efficient way to get a specific element from large tensors. size(D): Defaults to size(array(D)).

Tucker((G, A, B, ...))
Tucker((G, A, B, ...), frozen)

Tucker decomposition. Takes the form of a core G times a matrix for each dimension.

For example, a rank (r, s, t) Tucker decomposition of an order three tensor D would be, entry-wise,

D[i, j, k] = ∑_r ∑_s ∑_t G[r, s, t] * A[i, r] * B[j, s] * C[k, t].

Optionally use frozen::Tuple{Bool} to specify which factors are frozen.

See tuckerproduct.

Tucker(full_size::NTuple{N, Integer}, ranks::NTuple{N, Integer};
    frozen=false_tuple(length(ranks)+1), init=DEFAULT_INIT, kwargs...) where N

Constructs a random Tucker type using init to initialize the factors.

See Tucker1.

Tucker1((G, A))
Tucker1((G, A), frozen)

Tucker-1 decomposition. Takes the form of a core G times a matrix A. Entry-wise

D[i₁, …, i_N] = ∑_r G[r, i₂, …, i_N] * A[i₁, r].

Optionally use frozen::Tuple{Bool} to specify which factors are frozen.

See ×₁ and mtt.

Tucker1(full_size::NTuple{N, Integer}, rank::Integer; frozen=false_tuple(2), init=DEFAULT_INIT, kwargs...) where N

Constructs a random Tucker1 type using init to initialize the factors.

CP decomposition. Takes the form of an outerproduct of multiple matrices.

For example, a CP-decomposition of an order three tensor D would be, entry-wise,

D[i, j, k] = ∑_r A[i, r] * B[j, r] * C[k, r]).

CPDecomposition((A, B, C))

Abstract type for all Tucker-like decompositions. AbstractTucker decompositions have a core with the same number of dimensions as the full array, and (a) matrix factor(s).

Most general decomposition. Takes the form of interweaving contractions between the factors.

For example, T = A * B + C could be represented as GenericDecomposition((A, B, C), (*, +))

SingletonDecomposition(A::AbstractArray, frozen=false)

Wraps an AbstractArray so it can be treated like an AbstractDecomposition