code: def dropout_path(
      edge_index: Tensor,
      p: float = 0.2,
      walks_per_node: int = 1,
      walk_length: int = 3,
      num_nodes: Optional[int] = None,
      is_sorted: bool = False,
      training: bool = True,
  ) -> Tuple[Tensor, Tensor]:
      r"""Drops edges from the adjacency matrix :obj:`edge_index`
      based on random walks. The source nodes to start random walks from are
      sampled from :obj:`edge_index` with probability :obj:`p`, following
      a Bernoulli distribution.
  
      The method returns (1) the retained :obj:`edge_index`, (2) the edge mask
      indicating which edges were retained.
  
      Args:
          edge_index (LongTensor): The edge indices.
          p (float, optional): Sample probability. (default: :obj:`0.2`)
          walks_per_node (int, optional): The number of walks per node, same as
              :class:`~torch_geometric.nn.models.Node2Vec`. (default: :obj:`1`)
          walk_length (int, optional): The walk length, same as
              :class:`~torch_geometric.nn.models.Node2Vec`. (default: :obj:`3`)
          num_nodes (int, optional): The number of nodes, *i.e.*
              :obj:`max_val + 1` of :attr:`edge_index`. (default: :obj:`None`)
          is_sorted (bool, optional): If set to :obj:`True`, will expect
              :obj:`edge_index` to be already sorted row-wise.
              (default: :obj:`False`)
          training (bool, optional): If set to :obj:`False`, this operation is a
              no-op. (default: :obj:`True`)
  
      :rtype: (:class:`LongTensor`, :class:`BoolTensor`)
  
      Example:
          >>> edge_index = torch.tensor([[0, 1, 1, 2, 2, 3],
          ...                            [1, 0, 2, 1, 3, 2]])
          >>> edge_index, edge_mask = dropout_path(edge_index)
          >>> edge_index
          tensor([[1, 2],
                  [2, 3]])
          >>> edge_mask # masks indicating which edges are retained
          tensor([False, False,  True, False,  True, False])
      """
      if p < 0.0 or p > 1.0:
          raise ValueError(
              f"Sample probability has to be between 0 and 1 "
              f"(got {p}"
          )
  
      num_edges = edge_index.size(1)
      edge_mask = edge_index.new_ones(num_edges, dtype=torch.bool)
      if not training or p == 0.0:
          return edge_index, edge_mask
  
      if (
          not torch_geometric.typing.WITH_TORCH_CLUSTER
          or is_compiling()
      ):
          raise ImportError("`dropout_path` requires `torch-cluster`.")
  
      num_nodes = maybe_num_nodes(edge_index, num_nodes)
      edge_orders = None
      ori_edge_index = edge_index
      if not is_sorted:
          edge_orders = torch.arange(
              num_edges, device=edge_index.device
          )
          edge_index, edge_orders = sort_edge_index(
              edge_index, edge_orders, num_nodes=num_nodes
          )
  
      row, col = edge_index
      sample_mask = (
          torch.rand(row.size(0), device=edge_index.device) <= p
      )
      start = row[sample_mask].repeat(walks_per_node)
  
      rowptr = cumsum(
          degree(row, num_nodes=num_nodes, dtype=torch.long)
      )
      n_id, e_id = torch.ops.torch_cluster.random_walk(
          rowptr, col, start, walk_length, 1.0, 1.0
      )
      e_id = e_id[e_id != -1].view(-1)  # filter illegal edges
  
      if edge_orders is not None:  # Permute edge indices:
          e_id = edge_orders[e_id]
      edge_mask[e_id] = False
      edge_index = ori_edge_index[:, edge_mask]
  
      return edge_index, edge_mask
  
file_path: pytorch_geometric/torch_geometric/utils/dropout.py
imports: from typing import Optional, Tuple
  import torch
  from torch import Tensor
  import torch_geometric.typing
  from torch_geometric import is_compiling
  from torch_geometric.deprecation import deprecated
  from torch_geometric.typing import OptTensor
  from torch_geometric.utils import cumsum, degree, sort_edge_index, subgraph
  from torch_geometric.utils.num_nodes import maybe_num_nodes
label_desc: Use image node_id 5 for calling a global function with example usage: dropout_path(edge_index, p, walks_per_node, walk_length, num_nodes, is_sorted, training) and returns: edge_index,  edge_mask, edge_index,  edge_mask