code: def _segment_reduce(op, feat, offsets):
      r"""Segment reduction operator.
  
      It aggregates the value tensor along the first dimension by segments.
      The argument ``offsets`` specifies the start offset of each segment (and
      the upper bound of the last segment). Zero-length segments are allowed.
  
      .. math::
        y_i = \Phi_{j=\mathrm{offsets}_i}^{\mathrm{offsets}_{i+1}-1} x_j
  
      where :math:`\Phi` is the reduce operator.
  
      Parameters
      ----------
      op : str
          Aggregation method. Can be ``sum``, ``max``, ``min``.
      x : Tensor
          Value to aggregate.
      offsets : Tensor
          The start offsets of segments.
  
      Returns
      -------
      tuple(Tensor)
          The first tensor correspond to aggregated tensor of shape
          ``(len(seglen), value.shape[1:])``, and the second tensor records
          the argmin/max at each position for computing gradients.
  
      Notes
      -----
      This function does not handle gradients.
      """
      n = F.shape(offsets)[0] - 1
      out_shp = (n,) + F.shape(feat)[1:]
      ctx = F.context(feat)
      dtype = F.dtype(feat)
      idtype = F.dtype(offsets)
      out = F.zeros(out_shp, dtype, ctx)
      arg = None
      if op in ["min", "max"]:
          arg = F.zeros(out_shp, idtype, ctx)
      arg_nd = to_dgl_nd_for_write(arg)
      _CAPI_DGLKernelSegmentReduce(
          op,
          to_dgl_nd(feat),
          to_dgl_nd(offsets),
          to_dgl_nd_for_write(out),
          arg_nd,
      )
      arg = None if arg is None else F.zerocopy_from_dgl_ndarray(arg_nd)
      return out, arg
  
imports: from __future__ import absolute_import
  from .None import backend, ndarray
  from ._ffi.function import _init_api
  from .base import DGLError
label_desc: Use image node_id 15 for calling a global function with example usage: _segment_reduce(op, feat, offsets) and returns: out,  arg