code: def node_subgraph(
      graph,
      nodes,
      *,
      relabel_nodes=True,
      store_ids=True,
      output_device=None,
  ):
      """Return a subgraph induced on the given nodes.
  
      A node-induced subgraph is a graph with edges whose endpoints are both in the
      specified node set. In addition to extracting the subgraph, DGL also copies
      the features of the extracted nodes and edges to the resulting graph. The copy
      is *lazy* and incurs data movement only when needed.
  
      If the graph is heterogeneous, DGL extracts a subgraph per relation and composes
      them as the resulting graph. Thus, the resulting graph has the same set of relations
      as the input one.
  
      Parameters
      ----------
      graph : DGLGraph
          The graph to extract subgraphs from.
      nodes : nodes or dict[str, nodes]
          The nodes to form the subgraph, which cannot have any duplicate value. The result
          will be undefined otherwise. The allowed nodes formats are:
  
          * Int Tensor: Each element is a node ID. The tensor must have the same device type
            and ID data type as the graph's.
          * iterable[int]: Each element is a node ID.
          * Bool Tensor: Each :math:`i^{th}` element is a bool flag indicating whether
            node :math:`i` is in the subgraph.
  
          If the graph is homogeneous, one can directly pass the above formats.
          Otherwise, the argument must be a dictionary with keys being node types
          and values being the node IDs in the above formats.
      relabel_nodes : bool, optional
          If True, the extracted subgraph will only have the nodes in the specified node set
          and it will relabel the nodes in order.
      store_ids : bool, optional
          If True, it will store the raw IDs of the extracted edges in the ``edata`` of the
          resulting graph under name ``dgl.EID``; if ``relabel_nodes`` is ``True``, it will
          also store the raw IDs of the specified nodes in the ``ndata`` of the resulting
          graph under name ``dgl.NID``.
      output_device : Framework-specific device context object, optional
          The output device.  Default is the same as the input graph.
  
      Returns
      -------
      G : DGLGraph
          The subgraph.
  
      Notes
      -----
  
      This function discards the batch information. Please use
      :func:`dgl.DGLGraph.set_batch_num_nodes`
      and :func:`dgl.DGLGraph.set_batch_num_edges` on the transformed graph
      to maintain the information.
  
      Examples
      --------
      The following example uses PyTorch backend.
  
      >>> import dgl
      >>> import torch
  
      Extract a subgraph from a homogeneous graph.
  
      >>> g = dgl.graph(([0, 1, 2, 3, 4], [1, 2, 3, 4, 0]))  # 5-node cycle
      >>> sg = dgl.node_subgraph(g, [0, 1, 4])
      >>> sg
      Graph(num_nodes=3, num_edges=2,
            ndata_schemes={'_ID': Scheme(shape=(), dtype=torch.int64)}
            edata_schemes={'_ID': Scheme(shape=(), dtype=torch.int64)})
      >>> sg.edges()
      (tensor([0, 2]), tensor([1, 0]))
      >>> sg.ndata[dgl.NID]  # original node IDs
      tensor([0, 1, 4])
      >>> sg.edata[dgl.EID]  # original edge IDs
      tensor([0, 4])
  
      Specify nodes using a boolean mask.
  
      >>> nodes = torch.tensor([True, True, False, False, True])  # choose nodes [0, 1, 4]
      >>> dgl.node_subgraph(g, nodes)
      Graph(num_nodes=3, num_edges=2,
            ndata_schemes={'_ID': Scheme(shape=(), dtype=torch.int64)}
            edata_schemes={'_ID': Scheme(shape=(), dtype=torch.int64)})
  
      The resulting subgraph also copies features from the parent graph.
  
      >>> g.ndata['x'] = torch.arange(10).view(5, 2)
      >>> sg = dgl.node_subgraph(g, [0, 1, 4])
      >>> sg
      Graph(num_nodes=3, num_edges=2,
            ndata_schemes={'x': Scheme(shape=(2,), dtype=torch.int64),
                           '_ID': Scheme(shape=(), dtype=torch.int64)}
            edata_schemes={'_ID': Scheme(shape=(), dtype=torch.int64)})
      >>> sg.ndata['x']
      tensor([[0, 1],
              [2, 3],
              [8, 9]])
  
      Extract a subgraph from a hetergeneous graph.
  
      >>> g = dgl.heterograph({
      >>>     ('user', 'plays', 'game'): ([0, 1, 1, 2], [0, 0, 2, 1]),
      >>>     ('user', 'follows', 'user'): ([0, 1, 1], [1, 2, 2])
      >>> })
      >>> sub_g = dgl.node_subgraph(g, {'user': [1, 2]})
      >>> sub_g
      Graph(num_nodes={'game': 0, 'user': 2},
            num_edges={('user', 'follows', 'user'): 2, ('user', 'plays', 'game'): 0},
            metagraph=[('user', 'user', 'follows'), ('user', 'game', 'plays')])
  
      See Also
      --------
      edge_subgraph
      """
      if graph.is_block:
          raise DGLError(
              "Extracting subgraph from a block graph is not allowed."
          )
      if not isinstance(nodes, Mapping):
          assert (
              len(graph.ntypes) == 1
          ), "need a dict of node type and IDs for graph with multiple node types"
          nodes = {graph.ntypes[0]: nodes}
  
      def _process_nodes(ntype, v):
          if F.is_tensor(v) and F.dtype(v) == F.bool:
              return F.astype(
                  F.nonzero_1d(F.copy_to(v, graph.device)), graph.idtype
              )
          else:
              return utils.prepare_tensor(
                  graph, v, 'nodes["{}"]'.format(ntype)
              )
  
      nodes = {
          ntype: _process_nodes(ntype, v) for ntype, v in nodes.items()
      }
      device = context_of(nodes)
  
      induced_nodes = [
          nodes.get(
              ntype, F.copy_to(F.tensor([], graph.idtype), device)
          )
          for ntype in graph.ntypes
      ]
      sgi = graph._graph.node_subgraph(induced_nodes)
      induced_edges = sgi.induced_edges
      if not relabel_nodes:
          sgi = graph._graph.edge_subgraph(induced_edges, True)
      # (BarclayII) should not write induced_nodes = sgi.induced_nodes due to the same
      # bug in #1453.
      induced_nodes_or_device = (
          induced_nodes if relabel_nodes else device
      )
      subg = _create_hetero_subgraph(
          graph,
          sgi,
          induced_nodes_or_device,
          induced_edges,
          store_ids=store_ids,
      )
      return subg if output_device is None else subg.to(output_device)
  
file_path: dgl/python/dgl/subgraph.py
imports: from collections.abc import Mapping
  from .None import backend, graph_index, heterograph_index, utils
  from ._ffi.function import _init_api
  from .base import DGLError
  from .heterograph import DGLGraph
  from .utils import context_of, recursive_apply
label_desc: Use image node_id 1 for calling a global function with example usage: node_subgraph(graph, nodes) and returns: unknown, F, utils