class_docstr: Adaptive augmentation methods proposed in the paper `Graph Contrastive Learning
  with Adaptive Augmentation <https://arxiv.org/abs/2010.14945>`_. You can refer to `the original implementation 
  <https://github.com/CRIPAC-DIG/GCA>` or `the benchmark code 
  <https://github.com/divelab/DIG/blob/dig/benchmarks/sslgraph/example_grace.ipynb>`_ for
  an example of usage.
  
  *Alias*: :obj:`dig.sslgraph.method.contrastive.model.`:obj:`pGRACE`.
      
  Args:
      dim (int): The embedding dimension.
      proj_n_dim (int): The projection head dimension to use for computing loss
      centrality_measure (str): The metric to use for computing edge or node centrality. Supported values are `degree`, `evc` (Eigen-Vector centrality) and `pr` (PageRank centrality).
      prob_edge_1, prob_edge_2 (float): The probability factor for calculating edge-drop probability
      prob_feature_1, prob_feature_2 (float): The probability factor for calculating feature-masking probability
      tau (float, optional): The temperature parameter used for contrastive objective.
      dense (bool, optional): Whether the node features are dense continuous features. Defaults to `false`.
      p_tau (float, optional): The upper-bound probability for dropping edges or removing nodes.
      **kwargs (optional): Additional arguments of :class:`dig.sslgraph.method.Contrastive`.
code: def __init__(
      self,
      dim: int,
      proj_n_dim: int,
      centrality_measure: str,
      prob_edge_1: float,
      prob_edge_2: float,
      prob_feature_1: float,
      prob_feature_2: float,
      tau: float = 0.1,
      dense: bool = False,
      p_tau: float = 0.7,
      **kwargs,
  ):
      view_fn_1 = Sequential(
          [
              AdaEdgePerturbation(
                  centrality_measure, prob=prob_edge_1, threshold=p_tau
              ),
              AdaNodeAttrMask(
                  centrality_measure,
                  prob=prob_feature_1,
                  threshold=p_tau,
                  dense=dense,
              ),
          ]
      )
      view_fn_2 = Sequential(
          [
              AdaEdgePerturbation(
                  centrality_measure, prob=prob_edge_2, threshold=p_tau
              ),
              AdaNodeAttrMask(
                  centrality_measure,
                  prob=prob_feature_2,
                  threshold=p_tau,
                  dense=dense,
              ),
          ]
      )
      views_fn = [view_fn_1, view_fn_2]
  
      device = kwargs["device"] if "device" in kwargs else 0
  
      super(pGRACE, self).__init__(
          objective="NCE",
          views_fn=views_fn,
          graph_level=False,
          node_level=True,
          z_n_dim=dim,
          tau=tau,
          proj_n=self._proj_head,
          **kwargs,
      )
  
      self.proj_n = torch.nn.Sequential(
          torch.nn.Linear(dim, proj_n_dim),
          torch.nn.ELU(),
          torch.nn.Linear(proj_n_dim, dim),
      ).to(device)
  
imports: from .contrastive import Contrastive
  from dig.sslgraph.method.contrastive.views_fn import AdaNodeAttrMask, AdaEdgePerturbation, Sequential
  import torch
label_desc: Use image node_id 1 to create a new pGRACE object from inherited base classes: Contrastive with example: obj = pGRACE(dim, proj_n_dim, centrality_measure, prob_edge_1, prob_edge_2, prob_feature_1, prob_feature_2, tau, dense, p_tau)