code: def component_layout(
      data,
      n_components,
      component_labels,
      dim,
      random_state,
      metric="euclidean",
      metric_kwds={},
  ):
      """Provide a layout relating the separate connected components. This is done
      by taking the centroid of each component and then performing a spectral embedding
      of the centroids.
  
      Parameters
      ----------
      data: array of shape (n_samples, n_features)
          The source data -- required so we can generate centroids for each
          connected component of the graph.
  
      n_components: int
          The number of distinct components to be layed out.
  
      component_labels: array of shape (n_samples)
          For each vertex in the graph the label of the component to
          which the vertex belongs.
  
      dim: int
          The chosen embedding dimension.
  
      metric: string or callable (optional, default 'euclidean')
          The metric used to measure distances among the source data points.
  
      metric_kwds: dict (optional, default {})
          Keyword arguments to be passed to the metric function.
          If metric is 'precomputed', 'linkage' keyword can be used to specify
          'average', 'complete', or 'single' linkage. Default is 'average'
  
      Returns
      -------
      component_embedding: array of shape (n_components, dim)
          The ``dim``-dimensional embedding of the ``n_components``-many
          connected components.
      """
      if data is None:
          # We don't have data to work with; just guess
          return np.random.random(size=(n_components, dim)) * 10.0
  
      component_centroids = np.empty(
          (n_components, data.shape[1]), dtype=np.float64
      )
  
      if metric == "precomputed":
          # cannot compute centroids from precomputed distances
          # instead, compute centroid distances using linkage
          distance_matrix = np.zeros(
              (n_components, n_components), dtype=np.float64
          )
          linkage = metric_kwds.get("linkage", "average")
          if linkage == "average":
              linkage = np.mean
          elif linkage == "complete":
              linkage = np.max
          elif linkage == "single":
              linkage = np.min
          else:
              raise ValueError(
                  "Unrecognized linkage '%s'. Please choose from "
                  "'average', 'complete', or 'single'" % linkage
              )
          for c_i in range(n_components):
              dm_i = data[component_labels == c_i]
              for c_j in range(c_i + 1, n_components):
                  dist = linkage(dm_i[:, component_labels == c_j])
                  distance_matrix[c_i, c_j] = dist
                  distance_matrix[c_j, c_i] = dist
      else:
          for label in range(n_components):
              component_centroids[label] = data[
                  component_labels == label
              ].mean(axis=0)
  
          if scipy.sparse.isspmatrix(component_centroids):
              warn(
                  "Forcing component centroids to dense; if you are running out of "
                  "memory then consider increasing n_neighbors."
              )
              component_centroids = component_centroids.toarray()
  
          if metric in SPECIAL_METRICS:
              distance_matrix = pairwise_special_metric(
                  component_centroids,
                  metric=metric,
                  kwds=metric_kwds,
              )
          elif metric in SPARSE_SPECIAL_METRICS:
              distance_matrix = pairwise_special_metric(
                  component_centroids,
                  metric=SPARSE_SPECIAL_METRICS[metric],
                  kwds=metric_kwds,
              )
          else:
              if callable(metric) and scipy.sparse.isspmatrix(data):
                  function_to_name_mapping = {
                      sparse_named_distances[k]: k
                      for k in set(SKLEARN_PAIRWISE_VALID_METRICS)
                      & set(sparse_named_distances.keys())
                  }
                  try:
                      metric_name = function_to_name_mapping[metric]
                  except KeyError:
                      raise NotImplementedError(
                          "Multicomponent layout for custom "
                          "sparse metrics is not implemented at "
                          "this time."
                      )
                  distance_matrix = pairwise_distances(
                      component_centroids,
                      metric=metric_name,
                      **metric_kwds,
                  )
              else:
                  distance_matrix = pairwise_distances(
                      component_centroids, metric=metric, **metric_kwds
                  )
  
      affinity_matrix = np.exp(-(distance_matrix**2))
  
      component_embedding = SpectralEmbedding(
          n_components=dim,
          affinity="precomputed",
          random_state=random_state,
      ).fit_transform(affinity_matrix)
      component_embedding /= component_embedding.max()
  
      return component_embedding
  
file_path: umap/umap/spectral.py
imports: import warnings
  from warnings import warn
  import numpy
  import scipy.sparse
  import scipy.sparse.csgraph
  from sklearn.decomposition import TruncatedSVD
  from sklearn.manifold import SpectralEmbedding
  from sklearn.metrics import pairwise_distances
  from sklearn.metrics.pairwise import _VALID_METRICS
  from umap.distances import pairwise_special_metric, SPECIAL_METRICS
  from umap.sparse import SPARSE_SPECIAL_METRICS, sparse_named_distances
label_desc: Use image node_id 1 for calling a global function with example usage: component_layout(data, n_components, component_labels, dim, random_state, metric, metric_kwds) and returns: component_embedding, unknown