code: def _pagerank_numpy(
      G,
      alpha=0.85,
      personalization=None,
      weight="weight",
      dangling=None,
  ):
      """Returns the PageRank of the nodes in the graph.
  
      PageRank computes a ranking of the nodes in the graph G based on
      the structure of the incoming links. It was originally designed as
      an algorithm to rank web pages.
  
      Parameters
      ----------
      G : graph
        A NetworkX graph.  Undirected graphs will be converted to a directed
        graph with two directed edges for each undirected edge.
  
      alpha : float, optional
        Damping parameter for PageRank, default=0.85.
  
      personalization: dict, optional
        The "personalization vector" consisting of a dictionary with a
        key some subset of graph nodes and personalization value each of those.
        At least one personalization value must be non-zero.
        If not specified, a nodes personalization value will be zero.
        By default, a uniform distribution is used.
  
      weight : key, optional
        Edge data key to use as weight.  If None weights are set to 1.
  
      dangling: dict, optional
        The outedges to be assigned to any "dangling" nodes, i.e., nodes without
        any outedges. The dict key is the node the outedge points to and the dict
        value is the weight of that outedge. By default, dangling nodes are given
        outedges according to the personalization vector (uniform if not
        specified) This must be selected to result in an irreducible transition
        matrix (see notes under google_matrix). It may be common to have the
        dangling dict to be the same as the personalization dict.
  
      Returns
      -------
      pagerank : dictionary
         Dictionary of nodes with PageRank as value.
  
      Examples
      --------
      >>> from networkx.algorithms.link_analysis.pagerank_alg import _pagerank_numpy
      >>> G = nx.DiGraph(nx.path_graph(4))
      >>> pr = _pagerank_numpy(G, alpha=0.9)
  
      Notes
      -----
      The eigenvector calculation uses NumPy's interface to the LAPACK
      eigenvalue solvers.  This will be the fastest and most accurate
      for small graphs.
  
      This implementation works with Multi(Di)Graphs. For multigraphs the
      weight between two nodes is set to be the sum of all edge weights
      between those nodes.
  
      See Also
      --------
      pagerank, google_matrix
  
      References
      ----------
      .. [1] A. Langville and C. Meyer,
         "A survey of eigenvector methods of web information retrieval."
         http://citeseer.ist.psu.edu/713792.html
      .. [2] Page, Lawrence; Brin, Sergey; Motwani, Rajeev and Winograd, Terry,
         The PageRank citation ranking: Bringing order to the Web. 1999
         http://dbpubs.stanford.edu:8090/pub/showDoc.Fulltext?lang=en&doc=1999-66&format=pdf
      """
      import numpy as np
  
      if len(G) == 0:
          return {}
      M = google_matrix(
          G,
          alpha,
          personalization=personalization,
          weight=weight,
          dangling=dangling,
      )
      # use numpy LAPACK solver
      eigenvalues, eigenvectors = np.linalg.eig(M.T)
      ind = np.argmax(eigenvalues)
      # eigenvector of largest eigenvalue is at ind, normalized
      largest = np.array(eigenvectors[:, ind]).flatten().real
      norm = largest.sum()
      return dict(zip(G, map(float, largest / norm)))
  
imports: from warnings import warn
  import networkx
label_desc: Use image node_id 4 for calling a global function with example usage: _pagerank_numpy(G, alpha, personalization, weight, dangling) and returns: dict, dict