code: def pinsage_sample(
      graph,
      nodes,
      samples,
      top_k=10,
      proba=0.5,
      norm_bais=1.0,
      ignore_edges=set(),
  ):
      """Implement of graphsage sample.
  
      Reference paper: .
  
      Args:
          graph: A pgl graph instance
          nodes: Sample starting from nodes
          samples: A list, number of neighbors in each layer
          top_k: select the top_k visit count nodes to construct the edges
          proba: the probability to return the origin node
          norm_bais: the normlization for the visit count
          ignore_edges: list of edge(src, dst) will be ignored.
  
      Return:
          A list of subgraphs
      """
      start = time.time()
      num_layers = len(samples)
      start_nodes = nodes
      edges, weights = [], []
      layer_nodes, layer_edges, layer_weights = [], [], []
      ignore_edge_set = set(
          [edge_hash(src, dst) for src, dst in ignore_edges]
      )
  
      for layer_idx in reversed(range(num_layers)):
          if len(start_nodes) == 0:
              layer_nodes = [nodes] + layer_nodes
              layer_edges = [edges] + layer_edges
              layer_edges_weight = [weights] + layer_weights
              continue
          walks = random_walk_with_start_prob(
              graph, start_nodes, samples[layer_idx], proba=proba
          )
          walks = [walk[1:] for walk in walks]
          pred_edges = []
          pred_weights = []
          pred_nodes = []
          for node, walk in zip(start_nodes, walks):
              walk_nodes = []
              walk_weights = []
              count_sum = 0
  
              for random_walk_node in walk:
                  if (
                      len(ignore_edge_set) > 0
                      and random_walk_node != node
                      and edge_hash(random_walk_node, node)
                      in ignore_edge_set
                  ):
                      continue
                  walk_nodes.append(random_walk_node)
              unique, counts = np.unique(walk_nodes, return_counts=True)
              frequencies = np.asarray((unique, counts)).T
              frequencies = frequencies[np.argsort(frequencies[:, 1])]
              frequencies = frequencies[-1 * top_k :, :]
              for random_walk_node, random_count in zip(
                  frequencies[:, 0].tolist(), frequencies[:, 1].tolist()
              ):
                  pred_nodes.append(random_walk_node)
                  pred_edges.append((random_walk_node, node))
                  walk_weights.append(random_count)
                  count_sum += random_count
              count_sum += len(walk_weights) * norm_bais
              walk_weights = (np.array(walk_weights) + norm_bais) / (
                  count_sum
              )
              pred_weights.extend(walk_weights.tolist())
          last_node_set = set(nodes)
          nodes, edges, weights = flat_node_and_edge(
              [nodes, pred_nodes],
              [edges, pred_edges],
              [weights, pred_weights],
          )
  
          layer_edges = [edges] + layer_edges
          layer_weights = [weights] + layer_weights
          layer_nodes = [nodes] + layer_nodes
  
          start_nodes = list(set(nodes) - last_node_set)
          start = time.time()
  
      feed_dict = {}
  
      subgraphs = []
  
      for i in range(num_layers):
          edge_feat_dict = {
              "weight": np.array(layer_weights[i], dtype="float32")
          }
          subgraphs.append(
              graph.subgraph(
                  nodes=layer_nodes[0],
                  edges=layer_edges[i],
                  edge_feats=edge_feat_dict,
                  with_edge_feat=False,
              )
          )
          subgraphs[i].node_feat["index"] = np.array(
              layer_nodes[0], dtype="int64"
          )
  
      return subgraphs
  
file_path: PGL/legacy/pgl/sample.py
imports: import time
  import copy
  import numpy
  import pgl
  from pgl.utils.logger import log
  from pgl import graph_kernel
label_desc: Use image node_id 11 for calling a global function with example usage: pinsage_sample(graph, nodes, samples, top_k, proba, norm_bais, ignore_edges) and returns: subgraphs