code: def _segmented_knn_graph_blas(x, k, segs, dist="euclidean"):
      r"""Construct multiple graphs from multiple sets of points according to
      k-nearest-neighbor (KNN).
  
      This function first compute the distance matrix using BLAS matrix multiplication
      operation provided by backend frameworks. Then use topk algorithm to get
      k-nearest neighbors.
  
      Parameters
      ----------
      x : Tensor
          Coordinates/features of points. Must be 2D. It can be either on CPU or GPU.
      k : int
          The number of nearest neighbors per node.
      segs : list[int]
          Number of points in each point set. The numbers in :attr:`segs`
          must sum up to the number of rows in :attr:`x`.
      dist : str, optional
          The distance metric used to compute distance between points. It can be the following
          metrics:
          * 'euclidean': Use Euclidean distance (L2 norm) :math:`\sqrt{\sum_{i} (x_{i} - y_{i})^{2}}`.
          * 'cosine': Use cosine distance.
          (default: 'euclidean')
      """
      # if use cosine distance, normalize input points first
      # thus we can use euclidean distance to find knn equivalently.
      if dist == "cosine":
          l2_norm = lambda v: F.sqrt(F.sum(v * v, dim=1, keepdims=True))
          x = x / (l2_norm(x) + 1e-5)
  
      n_total_points, _ = F.shape(x)
      offset = np.insert(np.cumsum(segs), 0, 0)
      min_seg_size = np.min(segs)
      if k > min_seg_size:
          dgl_warning(
              "'k' should be less than or equal to the number of points in 'x'"
              "expect k <= {0}, got k = {1}, use k = {0}".format(
                  min_seg_size, k
              )
          )
          k = min_seg_size
  
      h_list = F.split(x, segs, 0)
      src = [
          F.argtopk(
              pairwise_squared_distance(h_g), k, 1, descending=False
          )
          + int(offset[i])
          for i, h_g in enumerate(h_list)
      ]
      src = F.cat(src, 0)
      ctx = F.context(x)
      dst = F.repeat(F.arange(0, n_total_points, ctx=ctx), k, dim=0)
      return convert.graph(
          (F.reshape(src, (-1,)), F.reshape(dst, (-1,)))
      )
  
imports: import copy
  from collections.abc import Iterable, Mapping
  import numpy
  import scipy.sparse
  import scipy.sparse.linalg
  from ..utils import version
  from ..None import backend, batch, convert, function, ndarray, subgraph, utils
  from .._ffi.function import _init_api
  from ..base import dgl_warning, DGLError, EID, NID
  from ..frame import Frame
  from ..heterograph import DGLGraph
  from ..heterograph_index import create_heterograph_from_relations, create_metagraph_index
  from ..partition import metis_partition, metis_partition_assignment, partition_graph_with_halo
  from ..sampling.neighbor import sample_neighbors
label_desc: Use image node_id 5 for calling a global function with example usage: _segmented_knn_graph_blas(x, k, segs, dist) and returns: convert