code: def linkx_homophily(graph, y):
      r"""Homophily measure from `Large Scale Learning on Non-Homophilous Graphs:
      New Benchmarks and Strong Simple Methods
      <https://arxiv.org/abs/2110.14446>`__
  
      Mathematically it is defined as follows:
  
      .. math::
        \frac{1}{C-1} \sum_{k=1}^{C} \max \left(0, \frac{\sum_{v\in C_k}|\{u\in
        \mathcal{N}(v): y_v = y_u \}|}{\sum_{v\in C_k}|\mathcal{N}(v)|} -
        \frac{|\mathcal{C}_k|}{|\mathcal{V}|} \right),
  
      where :math:`C` is the number of node classes, :math:`C_k` is the set of
      nodes that belong to class k, :math:`\mathcal{N}(v)` are the predecessors
      of node :math:`v`, :math:`y_v` is the class of node :math:`v`, and
      :math:`\mathcal{V}` is the set of nodes.
  
      Parameters
      ----------
      graph : DGLGraph
          The graph.
      y : torch.Tensor
          The node labels, which is a tensor of shape (|V|).
  
      Returns
      -------
      float
          The homophily value.
  
      Examples
      --------
      >>> import dgl
      >>> import torch
  
      >>> graph = dgl.graph(([0, 1, 2, 3], [1, 2, 0, 4]))
      >>> y = torch.tensor([0, 0, 0, 0, 1])
      >>> dgl.linkx_homophily(graph, y)
      0.19999998807907104
      """
      check_pytorch()
      with graph.local_scope():
          # Compute |{u\in N(v): y_v = y_u}| for each node v.
          # Handle the case where graph is of dtype int32.
          src, dst = get_long_edges(graph)
          # Compute y_v = y_u for all edges.
          graph.edata["same_class"] = (y[src] == y[dst]).float()
          graph.update_all(
              fn.copy_e("same_class", "m"),
              fn.sum("m", "same_class_deg"),
          )
  
          deg = graph.in_degrees().float()
          num_nodes = graph.num_nodes()
          num_classes = y.max(dim=0).values.item() + 1
  
          value = torch.tensor(0.0).to(graph.device)
          for k in range(num_classes):
              # Get the nodes that belong to class k.
              class_mask = y == k
              same_class_deg_k = graph.ndata["same_class_deg"][
                  class_mask
              ].sum()
              deg_k = deg[class_mask].sum()
              num_nodes_k = class_mask.sum()
              value += max(
                  0, same_class_deg_k / deg_k - num_nodes_k / num_nodes
              )
  
          return value.item() / (num_classes - 1)
  
imports: from .None import function, to_bidirected
label_desc: Use image node_id 5 for calling a global function with example usage: linkx_homophily(graph, y) and returns: unknown