class_docstr: Tucker decomposition via Higher Order Orthogonal Iteration (HOI).
  
  Decomposes `tensor` into a Tucker decomposition:
  ``tensor = [| core; factors[0], ...factors[-1] |]`` [1]_
  
  Parameters
  ----------
  tensor : ndarray
  rank : None, int or int list
      size of the core tensor, ``(len(ranks) == tensor.ndim)``
      if int, the same rank is used for all modes
  non_negative : bool, default is False
      if True, uses a non-negative Tucker via iterative multiplicative updates
      otherwise, uses a Higher-Order Orthogonal Iteration.
  fixed_factors : int list or None, default is None
      if not None, list of modes for which to keep the factors fixed.
      Only valid if a Tucker tensor is provided as init.
  n_iter_max : int
              maximum number of iteration
  init : {'svd', 'random'}, optional
  return_errors : boolean
      Indicates whether the algorithm should return all reconstruction errors
      and computation time of each iteration or not
      Default: False
  svd : str, default is 'truncated_svd'
      ignore if non_negative is True
      function to use to compute the SVD,
      acceptable values in tensorly.SVD_FUNS
  tol : float, optional
      tolerance: the algorithm stops when the variation in
      the reconstruction error is less than the tolerance
  random_state : {None, int, np.random.RandomState}
  verbose : int, optional
      level of verbosity
  
  Returns
  -------
  core : ndarray of size `ranks`
          core tensor of the Tucker decomposition
  factors : ndarray list
          list of factors of the Tucker decomposition.
          Its ``i``-th element is of shape ``(tensor.shape[i], ranks[i])``
  
  References
  ----------
  .. [1] T.G.Kolda and B.W.Bader, "Tensor Decompositions and Applications",
  SIAM REVIEW, vol. 51, n. 3, pp. 455-500, 2009.
code: def __init__(
      self,
      rank=None,
      n_iter_max=100,
      init="svd",
      return_errors=False,
      svd="truncated_svd",
      tol=10e-5,
      fixed_factors=None,
      random_state=None,
      mask=None,
      verbose=False,
  ):
      self.rank = rank
      self.fixed_factors = fixed_factors
      self.n_iter_max = n_iter_max
      self.init = init
      self.return_errors = return_errors
      self.svd = svd
      self.tol = tol
      self.random_state = random_state
      self.mask = mask
      self.verbose = verbose
  
imports: import tensorly
  from ._base_decomposition import DecompositionMixin
  from ..base import unfold
  from ..tenalg import multi_mode_dot, mode_dot
  from ..tucker_tensor import tucker_to_tensor, TuckerTensor, validate_tucker_rank, tucker_normalize
  from ..tenalg.proximal import hals_nnls, active_set_nnls, fista
  from math import sqrt
  import warnings
  from collections.abc import Iterable
  from ..tenalg.svd import svd_interface
label_desc: Use image node_id 1 to create a new Tucker object from inherited base classes: DecompositionMixin with example: obj = Tucker(rank, n_iter_max, init, return_errors, svd, tol, fixed_factors, random_state, mask, verbose)