code: def heterograph(
      data_dict, num_nodes_dict=None, idtype=None, device=None
  ):
      """Create a heterogeneous graph and return.
  
      Parameters
      ----------
      data_dict : graph data
          The dictionary data for constructing a heterogeneous graph. The keys are in the form of
          string triplets (src_type, edge_type, dst_type), specifying the source node,
          edge, and destination node types. The values are graph data in the form of
          :math:`(U, V)`, where :math:`(U[i], V[i])` forms the edge with ID :math:`i`.
          The allowed graph data formats are:
  
          - ``(Tensor, Tensor)``: Each tensor must be a 1D tensor containing node IDs. DGL calls
            this format "tuple of node-tensors". The tensors should have the same data type,
            which must be either int32 or int64. They should also have the same device context
            (see below the descriptions of :attr:`idtype` and :attr:`device`).
          - ``('coo', (Tensor, Tensor))``: Same as ``(Tensor, Tensor)``.
          - ``('csr', (Tensor, Tensor, Tensor))``: The three tensors form the CSR representation
            of the graph's adjacency matrix.  The first one is the row index pointer.  The
            second one is the column indices.  The third one is the edge IDs, which can be empty
            (i.e. with 0 elements) to represent consecutive integer IDs starting from 0.
          - ``('csc', (Tensor, Tensor, Tensor))``: The three tensors form the CSC representation
            of the graph's adjacency matrix.  The first one is the column index pointer.  The
            second one is the row indices.  The third one is the edge IDs, which can be empty
            to represent consecutive integer IDs starting from 0.
  
          The tensors can be replaced with any iterable of integers (e.g. list, tuple,
          numpy.ndarray).
      num_nodes_dict : dict[str, int], optional
          The number of nodes for some node types, which is a dictionary mapping a node type
          :math:`T` to the number of :math:`T`-typed nodes. If not given for a node type
          :math:`T`, DGL finds the largest ID appearing in *every* graph data whose source
          or destination node type is :math:`T`, and sets the number of nodes to be that ID
          plus one. If given and the value is no greater than the largest ID for some node type,
          DGL will raise an error. By default, DGL infers the number of nodes for all node types.
      idtype : int32 or int64, optional
          The data type for storing the structure-related graph information such as node and
          edge IDs. It should be a framework-specific data type object (e.g., ``torch.int32``).
          If ``None`` (default), DGL infers the ID type from the :attr:`data_dict` argument.
      device : device context, optional
          The device of the returned graph, which should be a framework-specific device object
          (e.g., ``torch.device``). If ``None`` (default), DGL uses the device of the tensors of
          the :attr:`data` argument. If :attr:`data` is not a tuple of node-tensors, the
          returned graph is on CPU.  If the specified :attr:`device` differs from that of the
          provided tensors, it casts the given tensors to the specified device first.
  
      Returns
      -------
      DGLGraph
          The created graph.
  
      Notes
      -----
      1. If the :attr:`idtype` argument is not given then:
  
         - in the case of the tuple of node-tensor format, DGL uses
           the data type of the given ID tensors.
         - in the case of the tuple of sequence format, DGL uses int64.
  
         Once the graph has been created, you can change the data type by using
         :func:`dgl.DGLGraph.long` or :func:`dgl.DGLGraph.int`.
  
         If the specified :attr:`idtype` argument differs from the data type of the provided
         tensors, it casts the given tensors to the specified data type first.
      2. The most efficient construction approach is to provide a tuple of node tensors without
         specifying :attr:`idtype` and :attr:`device`. This is because the returned graph shares
         the storage with the input node-tensors in this case.
      3. DGL internally maintains multiple copies of the graph structure in different sparse
         formats and chooses the most efficient one depending on the computation invoked.
         If memory usage becomes an issue in the case of large graphs, use
         :func:`dgl.DGLGraph.formats` to restrict the allowed formats.
      4. DGL internally decides a deterministic order for the same set of node types and canonical
         edge types, which does not necessarily follow the order in :attr:`data_dict`.
  
      Examples
      --------
  
      The following example uses PyTorch backend.
  
      >>> import dgl
      >>> import torch
  
      Create a heterograph with three canonical edge types.
  
      >>> data_dict = {
      ...     ('user', 'follows', 'user'): (torch.tensor([0, 1]), torch.tensor([1, 2])),
      ...     ('user', 'follows', 'topic'): (torch.tensor([1, 1]), torch.tensor([1, 2])),
      ...     ('user', 'plays', 'game'): (torch.tensor([0, 3]), torch.tensor([3, 4]))
      ... }
      >>> g = dgl.heterograph(data_dict)
      >>> g
      Graph(num_nodes={'game': 5, 'topic': 3, 'user': 4},
            num_edges={('user', 'follows', 'user'): 2, ('user', 'follows', 'topic'): 2,
                       ('user', 'plays', 'game'): 2},
            metagraph=[('user', 'user', 'follows'), ('user', 'topic', 'follows'),
                       ('user', 'game', 'plays')])
  
      Explicitly specify the number of nodes for each node type in the graph.
  
      >>> num_nodes_dict = {'user': 4, 'topic': 4, 'game': 6}
      >>> g = dgl.heterograph(data_dict, num_nodes_dict=num_nodes_dict)
  
      Create a graph on the first GPU with data type int32.
  
      >>> g = dgl.heterograph(data_dict, idtype=torch.int32, device='cuda:0')
      """
      # Convert all data to node tensors first
      node_tensor_dict = {}
      need_infer = num_nodes_dict is None
      if num_nodes_dict is None:
          num_nodes_dict = defaultdict(int)
      for (sty, ety, dty), data in data_dict.items():
          if isinstance(data, spmatrix):
              raise DGLError(
                  "dgl.heterograph no longer supports graph construction from a SciPy "
                  "sparse matrix, use dgl.from_scipy instead."
              )
  
          if isinstance(data, nx.Graph):
              raise DGLError(
                  "dgl.heterograph no longer supports graph construction from a NetworkX "
                  "graph, use dgl.from_networkx instead."
              )
          is_bipartite = sty != dty
          (
              (sparse_fmt, arrays),
              urange,
              vrange,
          ) = utils.graphdata2tensors(
              data, idtype, bipartite=is_bipartite
          )
          node_tensor_dict[(sty, ety, dty)] = (sparse_fmt, arrays)
          if need_infer:
              num_nodes_dict[sty] = max(num_nodes_dict[sty], urange)
              num_nodes_dict[dty] = max(num_nodes_dict[dty], vrange)
          else:  # sanity check
              if num_nodes_dict[sty] < urange:
                  raise DGLError(
                      "The given number of nodes of node type {} must be larger than"
                      " the max ID in the data, but got {} and {}.".format(
                          sty, num_nodes_dict[sty], urange - 1
                      )
                  )
              if num_nodes_dict[dty] < vrange:
                  raise DGLError(
                      "The given number of nodes of node type {} must be larger than"
                      " the max ID in the data, but got {} and {}.".format(
                          dty, num_nodes_dict[dty], vrange - 1
                      )
                  )
      # Create the graph
      (
          metagraph,
          ntypes,
          etypes,
          relations,
      ) = heterograph_index.create_metagraph_index(
          num_nodes_dict.keys(), node_tensor_dict.keys()
      )
      num_nodes_per_type = utils.toindex(
          [num_nodes_dict[ntype] for ntype in ntypes], "int64"
      )
      rel_graphs = []
      for srctype, etype, dsttype in relations:
          sparse_fmt, arrays = node_tensor_dict[
              (srctype, etype, dsttype)
          ]
          g = create_from_edges(
              sparse_fmt,
              arrays,
              srctype,
              etype,
              dsttype,
              num_nodes_dict[srctype],
              num_nodes_dict[dsttype],
          )
          rel_graphs.append(g)
  
      # create graph index
      hgidx = heterograph_index.create_heterograph_from_relations(
          metagraph,
          [rgrh._graph for rgrh in rel_graphs],
          num_nodes_per_type,
      )
      retg = DGLGraph(hgidx, ntypes, etypes)
  
      return retg.to(device)
  
imports: from collections import defaultdict
  from collections.abc import Mapping
  import networkx
  import numpy
  from scipy.sparse import spmatrix
  from .None import backend, graph_index, heterograph_index, utils
  from .base import DGLError, EID, ETYPE, NID, NTYPE
  from .heterograph import combine_frames, DGLBlock, DGLGraph
label_desc: Use image node_id 3 for calling a global function with example usage: heterograph(data_dict, num_nodes_dict, idtype, device) and returns: retg