docs: def simplicial_set_embedding(
      data,
      graph,
      n_components,
      initial_alpha,
      a,
      b,
      gamma,
      negative_sample_rate,
      n_epochs,
      init,
      random_state,
      metric,
      metric_kwds,
      verbose,
  ):
      """Perform a fuzzy simplicial set embedding, using a specified
      initialisation method and then minimizing the fuzzy set cross entropy
      between the 1-skeletons of the high and low dimensional fuzzy simplicial
      sets.
  
      Parameters
      ----------
      data: array of shape (n_samples, n_features)
          The source data to be embedded by UMAP.
  
      graph: sparse matrix
          The 1-skeleton of the high dimensional fuzzy simplicial set as
          represented by a graph for which we require a sparse matrix for the
          (weighted) adjacency matrix.
  
      n_components: int
          The dimensionality of the euclidean space into which to embed the data.
  
      initial_alpha: float
          Initial learning rate for the SGD.
  
      a: float
          Parameter of differentiable approximation of right adjoint functor
  
      b: float
          Parameter of differentiable approximation of right adjoint functor
  
      gamma: float
          Weight to apply to negative samples.
  
      negative_sample_rate: int (optional, default 5)
          The number of negative samples to select per positive sample
          in the optimization process. Increasing this value will result
          in greater repulsive force being applied, greater optimization
          cost, but slightly more accuracy.
  
      n_epochs: int (optional, default 0)
          The number of training epochs to be used in optimizing the
          low dimensional embedding. Larger values result in more accurate
          embeddings. If 0 is specified a value will be selected based on
          the size of the input dataset (200 for large datasets, 500 for small).
  
      init: string
          How to initialize the low dimensional embedding. Options are:
              * 'spectral': use a spectral embedding of the fuzzy 1-skeleton
              * 'random': assign initial embedding positions at random.
              * A numpy array of initial embedding positions.
  
      random_state: numpy RandomState or equivalent
          A state capable being used as a numpy random state.
  
      metric: string
          The metric used to measure distance in high dimensional space; used if
          multiple connected components need to be layed out.
  
      metric_kwds: dict
          Key word arguments to be passed to the metric function; used if
          multiple connected components need to be layed out.
  
      verbose: bool (optional, default False)
          Whether to report information on the current progress of the algorithm.
  
      Returns
      -------
      embedding: array of shape (n_samples, n_components)
          The optimized of ``graph`` into an ``n_components`` dimensional
          euclidean space.
      """
      graph = graph.tocoo()
      graph.sum_duplicates()
      n_vertices = graph.shape[1]
  
      if n_epochs <= 0:
          # For smaller datasets we can use more epochs
          if graph.shape[0] <= 10000:
              n_epochs = 500
          else:
              n_epochs = 200
  
      graph.data[graph.data < (graph.data.max() / float(n_epochs))] = 0.0
      graph.eliminate_zeros()
  
      if isinstance(init, str) and init == "random":
          embedding = random_state.uniform(
              low=-10.0, high=10.0, size=(graph.shape[0], n_components)
          ).astype(np.float32)
      elif isinstance(init, str) and init == "spectral":
          # We add a little noise to avoid local minima for optimization to come
          initialisation = spectral_layout(
              data,
              graph,
              n_components,
              random_state,
              metric=metric,
              metric_kwds=metric_kwds,
          )
          expansion = 10.0 / np.abs(initialisation).max()
          embedding = (initialisation * expansion).astype(
              np.float32
          ) + random_state.normal(
              scale=0.0001, size=[graph.shape[0], n_components]
          ).astype(
              np.float32
          )
      else:
          init_data = np.array(init)
          if len(init_data.shape) == 2:
              if np.unique(init_data, axis=0).shape[0] < init_data.shape[0]:
                  tree = KDTree(init_data)
                  dist, ind = tree.query(init_data, k=2)
                  nndist = np.mean(dist[:, 1])
                  embedding = init_data + np.random.normal(
                      scale=0.001 * nndist, size=init_data.shape
                  ).astype(np.float32)
              else:
                  embedding = init_data
  
      epochs_per_sample = make_epochs_per_sample(graph.data, n_epochs)
  
      head = graph.row
      tail = graph.col
  
      rng_state = random_state.randint(INT32_MIN, INT32_MAX, 3).astype(np.int64)
      embedding = optimize_layout(
          embedding,
          embedding,
          head,
          tail,
          n_epochs,
          n_vertices,
          epochs_per_sample,
          a,
          b,
          rng_state,
          gamma,
          initial_alpha,
          negative_sample_rate,
          verbose=verbose,
      )
  
      return embedding