code: def fuzzy_simplicial_set(
      X,
      n_neighbors,
      random_state,
      metric,
      metric_kwds={},
      knn_indices=None,
      knn_dists=None,
      angular=False,
      set_op_mix_ratio=1.0,
      local_connectivity=1.0,
      apply_set_operations=True,
      verbose=False,
      return_dists=None,
  ):
      """Given a set of data X, a neighborhood size, and a measure of distance
      compute the fuzzy simplicial set (here represented as a fuzzy graph in
      the form of a sparse matrix) associated to the data. This is done by
      locally approximating geodesic distance at each point, creating a fuzzy
      simplicial set for each such point, and then combining all the local
      fuzzy simplicial sets into a global one via a fuzzy union.
  
      Parameters
      ----------
      X: array of shape (n_samples, n_features)
          The data to be modelled as a fuzzy simplicial set.
  
      n_neighbors: int
          The number of neighbors to use to approximate geodesic distance.
          Larger numbers induce more global estimates of the manifold that can
          miss finer detail, while smaller values will focus on fine manifold
          structure to the detriment of the larger picture.
  
      random_state: numpy RandomState or equivalent
          A state capable being used as a numpy random state.
  
      metric: string or function (optional, default 'euclidean')
          The metric to use to compute distances in high dimensional space.
          If a string is passed it must match a valid predefined metric. If
          a general metric is required a function that takes two 1d arrays and
          returns a float can be provided. For performance purposes it is
          required that this be a numba jit'd function. Valid string metrics
          include:
  
          * euclidean (or l2)
          * manhattan (or l1)
          * cityblock
          * braycurtis
          * canberra
          * chebyshev
          * correlation
          * cosine
          * dice
          * hamming
          * jaccard
          * kulsinski
          * ll_dirichlet
          * mahalanobis
          * matching
          * minkowski
          * rogerstanimoto
          * russellrao
          * seuclidean
          * sokalmichener
          * sokalsneath
          * sqeuclidean
          * yule
          * wminkowski
  
          Metrics that take arguments (such as minkowski, mahalanobis etc.)
          can have arguments passed via the metric_kwds dictionary. At this
          time care must be taken and dictionary elements must be ordered
          appropriately; this will hopefully be fixed in the future.
  
      metric_kwds: dict (optional, default {})
          Arguments to pass on to the metric, such as the ``p`` value for
          Minkowski distance.
  
      knn_indices: array of shape (n_samples, n_neighbors) (optional)
          If the k-nearest neighbors of each point has already been calculated
          you can pass them in here to save computation time. This should be
          an array with the indices of the k-nearest neighbors as a row for
          each data point.
  
      knn_dists: array of shape (n_samples, n_neighbors) (optional)
          If the k-nearest neighbors of each point has already been calculated
          you can pass them in here to save computation time. This should be
          an array with the distances of the k-nearest neighbors as a row for
          each data point.
  
      angular: bool (optional, default False)
          Whether to use angular/cosine distance for the random projection
          forest for seeding NN-descent to determine approximate nearest
          neighbors.
  
      set_op_mix_ratio: float (optional, default 1.0)
          Interpolate between (fuzzy) union and intersection as the set operation
          used to combine local fuzzy simplicial sets to obtain a global fuzzy
          simplicial sets. Both fuzzy set operations use the product t-norm.
          The value of this parameter should be between 0.0 and 1.0; a value of
          1.0 will use a pure fuzzy union, while 0.0 will use a pure fuzzy
          intersection.
  
      local_connectivity: int (optional, default 1)
          The local connectivity required -- i.e. the number of nearest
          neighbors that should be assumed to be connected at a local level.
          The higher this value the more connected the manifold becomes
          locally. In practice this should be not more than the local intrinsic
          dimension of the manifold.
  
      verbose: bool (optional, default False)
          Whether to report information on the current progress of the algorithm.
  
      return_dists: bool or None (optional, default None)
          Whether to return the pairwise distance associated with each edge.
  
      Returns
      -------
      fuzzy_simplicial_set: coo_matrix
          A fuzzy simplicial set represented as a sparse matrix. The (i,
          j) entry of the matrix represents the membership strength of the
          1-simplex between the ith and jth sample points.
      """
      if knn_indices is None or knn_dists is None:
          knn_indices, knn_dists, _ = nearest_neighbors(
              X,
              n_neighbors,
              metric,
              metric_kwds,
              angular,
              random_state,
              verbose=verbose,
          )
  
      knn_dists = knn_dists.astype(np.float32)
  
      sigmas, rhos = smooth_knn_dist(
          knn_dists,
          float(n_neighbors),
          local_connectivity=float(local_connectivity),
      )
  
      rows, cols, vals, dists = compute_membership_strengths(
          knn_indices, knn_dists, sigmas, rhos, return_dists
      )
  
      result = scipy.sparse.coo_matrix(
          (vals, (rows, cols)), shape=(X.shape[0], X.shape[0])
      )
      result.eliminate_zeros()
  
      if apply_set_operations:
          transpose = result.transpose()
  
          prod_matrix = result.multiply(transpose)
  
          result = (
              set_op_mix_ratio * (result + transpose - prod_matrix)
              + (1.0 - set_op_mix_ratio) * prod_matrix
          )
  
      result.eliminate_zeros()
  
      if return_dists is None:
          return result, sigmas, rhos
      else:
          if return_dists:
              dmat = scipy.sparse.coo_matrix(
                  (dists, (rows, cols)), shape=(X.shape[0], X.shape[0])
              )
  
              dists = dmat.maximum(dmat.transpose()).todok()
          else:
              dists = None
  
          return result, sigmas, rhos, dists
  
imports: from __future__ import print_function
  import locale
  from warnings import warn
  import time
  from scipy.optimize import curve_fit
  from sklearn.base import BaseEstimator
  from sklearn.utils import check_random_state, check_array
  from sklearn.utils.validation import check_is_fitted
  from sklearn.metrics import pairwise_distances
  from sklearn.preprocessing import normalize
  from sklearn.neighbors import KDTree
  from sklearn.decomposition import PCA, TruncatedSVD
  import numpy
  import scipy.sparse
  from scipy.sparse import tril, triu
  import scipy.sparse.csgraph
  import numba
  import umap.distances
  import umap.sparse
  from umap.utils import submatrix, ts, csr_unique, fast_knn_indices
  from umap.spectral import spectral_layout, tswspectral_layout
  from umap.layouts import optimize_layout_euclidean, optimize_layout_generic, optimize_layout_inverse
  from pynndescent import NNDescent
  from pynndescent.distances import named_distances
  from pynndescent.sparse import sparse_named_distances
label_desc: Use image node_id 8 for calling a global function with example usage: fuzzy_simplicial_set(X, n_neighbors, random_state, metric, metric_kwds, knn_indices, knn_dists, angular, set_op_mix_ratio, local_connectivity, apply_set_operations, verbose, return_dists) and returns: result,  sigmas,  rhos, result,  sigmas,  rhos,  dists