class_docstr: Spectral biclustering (Kluger, 2003).
  
  Partitions rows and columns under the assumption that the data has
  an underlying checkerboard structure. For instance, if there are
  two row partitions and three column partitions, each row will
  belong to three biclusters, and each column will belong to two
  biclusters. The outer product of the corresponding row and column
  label vectors gives this checkerboard structure.
  
  Read more in the :ref:`User Guide <spectral_biclustering>`.
  
  Parameters
  ----------
  n_clusters : integer or tuple (n_row_clusters, n_column_clusters)
      The number of row and column clusters in the checkerboard
      structure.
  
  method : string, optional, default: 'bistochastic'
      Method of normalizing and converting singular vectors into
      biclusters. May be one of 'scale', 'bistochastic', or 'log'.
      The authors recommend using 'log'. If the data is sparse,
      however, log normalization will not work, which is why the
      default is 'bistochastic'. CAUTION: if `method='log'`, the
      data must not be sparse.
  
  n_components : integer, optional, default: 6
      Number of singular vectors to check.
  
  n_best : integer, optional, default: 3
      Number of best singular vectors to which to project the data
      for clustering.
  
  svd_method : string, optional, default: 'randomized'
      Selects the algorithm for finding singular vectors. May be
      'randomized' or 'arpack'. If 'randomized', uses
      `sklearn.utils.extmath.randomized_svd`, which may be faster
      for large matrices. If 'arpack', uses
      `sklearn.utils.arpack.svds`, which is more accurate, but
      possibly slower in some cases.
  
  n_svd_vecs : int, optional, default: None
      Number of vectors to use in calculating the SVD. Corresponds
      to `ncv` when `svd_method=arpack` and `n_oversamples` when
      `svd_method` is 'randomized`.
  
  mini_batch : bool, optional, default: False
      Whether to use mini-batch k-means, which is faster but may get
      different results.
  
  init : {'k-means++', 'random' or an ndarray}
       Method for initialization of k-means algorithm; defaults to
       'k-means++'.
  
  n_init : int, optional, default: 10
      Number of random initializations that are tried with the
      k-means algorithm.
  
      If mini-batch k-means is used, the best initialization is
      chosen and the algorithm runs once. Otherwise, the algorithm
      is run for each initialization and the best solution chosen.
  
  n_jobs : int, optional, default: 1
      The number of jobs to use for the computation. This works by breaking
      down the pairwise matrix into n_jobs even slices and computing them in
      parallel.
  
      If -1 all CPUs are used. If 1 is given, no parallel computing code is
      used at all, which is useful for debugging. For n_jobs below -1,
      (n_cpus + 1 + n_jobs) are used. Thus for n_jobs = -2, all CPUs but one
      are used.
  
  random_state : int seed, RandomState instance, or None (default)
      A pseudo random number generator used by the K-Means
      initialization.
  
  Attributes
  ----------
  rows_ : array-like, shape (n_row_clusters, n_rows)
      Results of the clustering. `rows[i, r]` is True if
      cluster `i` contains row `r`. Available only after calling ``fit``.
  
  columns_ : array-like, shape (n_column_clusters, n_columns)
      Results of the clustering, like `rows`.
  
  row_labels_ : array-like, shape (n_rows,)
      Row partition labels.
  
  column_labels_ : array-like, shape (n_cols,)
      Column partition labels.
  
  References
  ----------
  
  * Kluger, Yuval, et. al., 2003. `Spectral biclustering of microarray
    data: coclustering genes and conditions
    <http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.135.1608>`__.
code: def __init__(
      self,
      n_clusters=3,
      method="bistochastic",
      n_components=6,
      n_best=3,
      svd_method="randomized",
      n_svd_vecs=None,
      mini_batch=False,
      init="k-means++",
      n_init=10,
      n_jobs=1,
      random_state=None,
  ):
      super(SpectralBiclustering, self).__init__(
          n_clusters,
          svd_method,
          n_svd_vecs,
          mini_batch,
          init,
          n_init,
          n_jobs,
          random_state,
      )
      self.method = method
      self.n_components = n_components
      self.n_best = n_best
  
imports: from abc import ABCMeta, abstractmethod
  import numpy
  from scipy.sparse import dia_matrix
  from scipy.sparse import issparse
  from .None import KMeans, MiniBatchKMeans
  from ..base import BaseEstimator, BiclusterMixin
  from ..externals import six
  from ..utils import check_random_state
  from ..utils.arpack import eigsh, svds
  from ..utils.extmath import make_nonnegative, norm, randomized_svd, safe_sparse_dot
  from ..utils.validation import assert_all_finite, check_array
label_desc: Use image node_id 1 to create a new SpectralBiclustering object from inherited base classes: BaseSpectral with example: obj = SpectralBiclustering(n_clusters, method, n_components, n_best, svd_method, n_svd_vecs, mini_batch, init, n_init, n_jobs, random_state)