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 fit_transform(self, tensor):
      tucker_tensor = tucker(
          tensor,
          rank=self.rank,
          fixed_factors=self.fixed_factors,
          n_iter_max=self.n_iter_max,
          init=self.init,
          return_errors=self.return_errors,
          svd=self.svd,
          tol=self.tol,
          random_state=self.random_state,
          mask=self.mask,
          verbose=self.verbose,
      )
      self.decomposition_ = tucker_tensor
      return tucker_tensor
  
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 2 for calling the Tucker obj's underlying member method code with example usage: obj.fit_transform(tensor) and returns: tucker_tensor