code: def spectral_embedding(
      adjacency,
      n_components=8,
      eigen_solver=None,
      random_state=None,
      eigen_tol=0.0,
      norm_laplacian=True,
      drop_first=True,
  ):
      """Project the sample on the first eigenvectors of the graph Laplacian.
  
      The adjacency matrix is used to compute a normalized graph Laplacian
      whose spectrum (especially the eigenvectors associated to the
      smallest eigenvalues) has an interpretation in terms of minimal
      number of cuts necessary to split the graph into comparably sized
      components.
  
      This embedding can also 'work' even if the ``adjacency`` variable is
      not strictly the adjacency matrix of a graph but more generally
      an affinity or similarity matrix between samples (for instance the
      heat kernel of a euclidean distance matrix or a k-NN matrix).
  
      However care must taken to always make the affinity matrix symmetric
      so that the eigenvector decomposition works as expected.
  
      Read more in the :ref:`User Guide <spectral_embedding>`.
  
      Parameters
      ----------
      adjacency : array-like or sparse matrix, shape: (n_samples, n_samples)
          The adjacency matrix of the graph to embed.
  
      n_components : integer, optional, default 8
          The dimension of the projection subspace.
  
      eigen_solver : {None, 'arpack', 'lobpcg', or 'amg'}, default None
          The eigenvalue decomposition strategy to use. AMG requires pyamg
          to be installed. It can be faster on very large, sparse problems,
          but may also lead to instabilities.
  
      random_state : int seed, RandomState instance, or None (default)
          A pseudo random number generator used for the initialization of the
          lobpcg eigenvectors decomposition when eigen_solver == 'amg'.
          By default, arpack is used.
  
      eigen_tol : float, optional, default=0.0
          Stopping criterion for eigendecomposition of the Laplacian matrix
          when using arpack eigen_solver.
  
      drop_first : bool, optional, default=True
          Whether to drop the first eigenvector. For spectral embedding, this
          should be True as the first eigenvector should be constant vector for
          connected graph, but for spectral clustering, this should be kept as
          False to retain the first eigenvector.
  
      norm_laplacian : bool, optional, default=True
          If True, then compute normalized Laplacian.
  
      Returns
      -------
      embedding : array, shape=(n_samples, n_components)
          The reduced samples.
  
      Notes
      -----
      Spectral embedding is most useful when the graph has one connected
      component. If there graph has many components, the first few eigenvectors
      will simply uncover the connected components of the graph.
  
      References
      ----------
      * https://en.wikipedia.org/wiki/LOBPCG
  
      * Toward the Optimal Preconditioned Eigensolver: Locally Optimal
        Block Preconditioned Conjugate Gradient Method
        Andrew V. Knyazev
        http://dx.doi.org/10.1137%2FS1064827500366124
      """
      adjacency = check_symmetric(adjacency)
  
      try:
          from pyamg import smoothed_aggregation_solver
      except ImportError:
          if eigen_solver == "amg":
              raise ValueError(
                  "The eigen_solver was set to 'amg', but pyamg is "
                  "not available."
              )
  
      if eigen_solver is None:
          eigen_solver = "arpack"
      elif eigen_solver not in ("arpack", "lobpcg", "amg"):
          raise ValueError(
              "Unknown value for eigen_solver: '%s'."
              "Should be 'amg', 'arpack', or 'lobpcg'" % eigen_solver
          )
  
      random_state = check_random_state(random_state)
  
      n_nodes = adjacency.shape[0]
      # Whether to drop the first eigenvector
      if drop_first:
          n_components = n_components + 1
  
      if not _graph_is_connected(adjacency):
          warnings.warn(
              "Graph is not fully connected, spectral embedding"
              " may not work as expected."
          )
  
      laplacian, dd = graph_laplacian(
          adjacency, normed=norm_laplacian, return_diag=True
      )
      if (
          eigen_solver == "arpack"
          or eigen_solver != "lobpcg"
          and (
              not sparse.isspmatrix(laplacian)
              or n_nodes < 5 * n_components
          )
      ):
          # lobpcg used with eigen_solver='amg' has bugs for low number of nodes
          # for details see the source code in scipy:
          # https://github.com/scipy/scipy/blob/v0.11.0/scipy/sparse/linalg/eigen
          # /lobpcg/lobpcg.py#L237
          # or matlab:
          # http://www.mathworks.com/matlabcentral/fileexchange/48-lobpcg-m
          laplacian = _set_diag(laplacian, 1, norm_laplacian)
  
          # Here we'll use shift-invert mode for fast eigenvalues
          # (see http://docs.scipy.org/doc/scipy/reference/tutorial/arpack.html
          #  for a short explanation of what this means)
          # Because the normalized Laplacian has eigenvalues between 0 and 2,
          # I - L has eigenvalues between -1 and 1.  ARPACK is most efficient
          # when finding eigenvalues of largest magnitude (keyword which='LM')
          # and when these eigenvalues are very large compared to the rest.
          # For very large, very sparse graphs, I - L can have many, many
          # eigenvalues very near 1.0.  This leads to slow convergence.  So
          # instead, we'll use ARPACK's shift-invert mode, asking for the
          # eigenvalues near 1.0.  This effectively spreads-out the spectrum
          # near 1.0 and leads to much faster convergence: potentially an
          # orders-of-magnitude speedup over simply using keyword which='LA'
          # in standard mode.
          try:
              # We are computing the opposite of the laplacian inplace so as
              # to spare a memory allocation of a possibly very large array
              laplacian *= -1
              v0 = random_state.uniform(-1, 1, laplacian.shape[0])
              lambdas, diffusion_map = eigsh(
                  laplacian,
                  k=n_components,
                  sigma=1.0,
                  which="LM",
                  tol=eigen_tol,
                  v0=v0,
              )
              embedding = diffusion_map.T[n_components::-1] * dd
          except RuntimeError:
              # When submatrices are exactly singular, an LU decomposition
              # in arpack fails. We fallback to lobpcg
              eigen_solver = "lobpcg"
              # Revert the laplacian to its opposite to have lobpcg work
              laplacian *= -1
  
      if eigen_solver == "amg":
          # Use AMG to get a preconditioner and speed up the eigenvalue
          # problem.
          if not sparse.issparse(laplacian):
              warnings.warn("AMG works better for sparse matrices")
          # lobpcg needs double precision floats
          laplacian = check_array(
              laplacian, dtype=np.float64, accept_sparse=True
          )
          laplacian = _set_diag(laplacian, 1, norm_laplacian)
          ml = smoothed_aggregation_solver(
              check_array(laplacian, "csr")
          )
          M = ml.aspreconditioner()
          X = random_state.rand(laplacian.shape[0], n_components + 1)
          X[:, 0] = dd.ravel()
          lambdas, diffusion_map = lobpcg(
              laplacian, X, M=M, tol=1.0e-12, largest=False
          )
          embedding = diffusion_map.T * dd
          if embedding.shape[0] == 1:
              raise ValueError
  
      elif eigen_solver == "lobpcg":
          # lobpcg needs double precision floats
          laplacian = check_array(
              laplacian, dtype=np.float64, accept_sparse=True
          )
          if n_nodes < 5 * n_components + 1:
              # see note above under arpack why lobpcg has problems with small
              # number of nodes
              # lobpcg will fallback to eigh, so we short circuit it
              if sparse.isspmatrix(laplacian):
                  laplacian = laplacian.toarray()
              lambdas, diffusion_map = eigh(laplacian)
              embedding = diffusion_map.T[:n_components] * dd
          else:
              laplacian = _set_diag(laplacian, 1, norm_laplacian)
              # We increase the number of eigenvectors requested, as lobpcg
              # doesn't behave well in low dimension
              X = random_state.rand(
                  laplacian.shape[0], n_components + 1
              )
              X[:, 0] = dd.ravel()
              lambdas, diffusion_map = lobpcg(
                  laplacian, X, tol=1e-15, largest=False, maxiter=2000
              )
              embedding = diffusion_map.T[:n_components] * dd
              if embedding.shape[0] == 1:
                  raise ValueError
  
      embedding = _deterministic_vector_sign_flip(embedding)
      if drop_first:
          return embedding[1:n_components].T
      else:
          return embedding[:n_components].T
  
imports: import warnings
  import numpy
  from scipy import sparse
  from scipy.linalg import eigh
  from scipy.sparse.linalg import lobpcg
  from ..base import BaseEstimator
  from ..externals import six
  from ..utils import check_random_state, check_array, check_symmetric
  from ..utils.extmath import _deterministic_vector_sign_flip
  from ..utils.graph import graph_laplacian
  from ..utils.sparsetools import connected_components
  from ..utils.arpack import eigsh
  from ..metrics.pairwise import rbf_kernel
  from ..neighbors import kneighbors_graph
label_desc: Use image node_id 4 for calling a global function with example usage: spectral_embedding(adjacency, n_components, eigen_solver, random_state, eigen_tol, norm_laplacian, drop_first) and returns: embedding, embedding