code: def number_of_walks(G, walk_length):
      """Returns the number of walks connecting each pair of nodes in `G`
  
      A *walk* is a sequence of nodes in which each adjacent pair of nodes
      in the sequence is adjacent in the graph. A walk can repeat the same
      edge and go in the opposite direction just as people can walk on a
      set of paths, but standing still is not counted as part of the walk.
  
      This function only counts the walks with `walk_length` edges. Note that
      the number of nodes in the walk sequence is one more than `walk_length`.
      The number of walks can grow very quickly on a larger graph
      and with a larger walk length.
  
      Parameters
      ----------
      G : NetworkX graph
  
      walk_length : int
          A nonnegative integer representing the length of a walk.
  
      Returns
      -------
      dict
          A dictionary of dictionaries in which outer keys are source
          nodes, inner keys are target nodes, and inner values are the
          number of walks of length `walk_length` connecting those nodes.
  
      Raises
      ------
      ValueError
          If `walk_length` is negative
  
      Examples
      --------
  
      >>> G = nx.Graph([(0, 1), (1, 2)])
      >>> walks = nx.number_of_walks(G, 2)
      >>> walks
      {0: {0: 1, 1: 0, 2: 1}, 1: {0: 0, 1: 2, 2: 0}, 2: {0: 1, 1: 0, 2: 1}}
      >>> total_walks = sum(sum(tgts.values()) for _, tgts in walks.items())
  
      You can also get the number of walks from a specific source node using the
      returned dictionary. For example, number of walks of length 1 from node 0
      can be found as follows:
  
      >>> walks = nx.number_of_walks(G, 1)
      >>> walks[0]
      {0: 0, 1: 1, 2: 0}
      >>> sum(walks[0].values())  # walks from 0 of length 1
      1
  
      Similarly, a target node can also be specified:
  
      >>> walks[0][1]
      1
  
      """
      import numpy as np
  
      if walk_length < 0:
          raise ValueError(
              f"`walk_length` cannot be negative: {walk_length}"
          )
  
      A = nx.adjacency_matrix(G, weight=None)
      # TODO: Use matrix_power from scipy.sparse when available
      # power = sp.sparse.linalg.matrix_power(A, walk_length)
      power = np.linalg.matrix_power(A.toarray(), walk_length)
      result = {
          u: {v: power[u_idx, v_idx] for v_idx, v in enumerate(G)}
          for u_idx, u in enumerate(G)
      }
      return result
  
label_desc: Use image node_id 1 for calling a global function with example usage: number_of_walks(G, walk_length) and returns: result