class_docstr: The GATv2 operator from the `"How Attentive are Graph Attention
  Networks?" <https://arxiv.org/abs/2105.14491>`_ paper, which fixes the
  static attention problem of the standard
  :class:`~torch_geometric.conv.GATConv` layer.
  Since the linear layers in the standard GAT are applied right after each
  other, the ranking of attended nodes is unconditioned on the query node.
  In contrast, in :class:`GATv2`, every node can attend to any other node.
  
  .. math::
      \mathbf{x}^{\prime}_i = \alpha_{i,i}\mathbf{\Theta}_{s}\mathbf{x}_{i} +
      \sum_{j \in \mathcal{N}(i)}
      \alpha_{i,j}\mathbf{\Theta}_{t}\mathbf{x}_{j},
  
  where the attention coefficients :math:`\alpha_{i,j}` are computed as
  
  .. math::
      \alpha_{i,j} =
      \frac{
      \exp\left(\mathbf{a}^{\top}\mathrm{LeakyReLU}\left(
      \mathbf{\Theta}_{s} \mathbf{x}_i + \mathbf{\Theta}_{t} \mathbf{x}_j
      \right)\right)}
      {\sum_{k \in \mathcal{N}(i) \cup \{ i \}}
      \exp\left(\mathbf{a}^{\top}\mathrm{LeakyReLU}\left(
      \mathbf{\Theta}_{s} \mathbf{x}_i + \mathbf{\Theta}_{t} \mathbf{x}_k
      \right)\right)}.
  
  If the graph has multi-dimensional edge features :math:`\mathbf{e}_{i,j}`,
  the attention coefficients :math:`\alpha_{i,j}` are computed as
  
  .. math::
      \alpha_{i,j} =
      \frac{
      \exp\left(\mathbf{a}^{\top}\mathrm{LeakyReLU}\left(
      \mathbf{\Theta}_{s} \mathbf{x}_i
      + \mathbf{\Theta}_{t} \mathbf{x}_j
      + \mathbf{\Theta}_{e} \mathbf{e}_{i,j}
      \right)\right)}
      {\sum_{k \in \mathcal{N}(i) \cup \{ i \}}
      \exp\left(\mathbf{a}^{\top}\mathrm{LeakyReLU}\left(
      \mathbf{\Theta}_{s} \mathbf{x}_i
      + \mathbf{\Theta}_{t} \mathbf{x}_k
      + \mathbf{\Theta}_{e} \mathbf{e}_{i,k}]
      \right)\right)}.
  
  Args:
      in_channels (int or tuple): Size of each input sample, or :obj:`-1` to
          derive the size from the first input(s) to the forward method.
          A tuple corresponds to the sizes of source and target
          dimensionalities in case of a bipartite graph.
      out_channels (int): Size of each output sample.
      heads (int, optional): Number of multi-head-attentions.
          (default: :obj:`1`)
      concat (bool, optional): If set to :obj:`False`, the multi-head
          attentions are averaged instead of concatenated.
          (default: :obj:`True`)
      negative_slope (float, optional): LeakyReLU angle of the negative
          slope. (default: :obj:`0.2`)
      dropout (float, optional): Dropout probability of the normalized
          attention coefficients which exposes each node to a stochastically
          sampled neighborhood during training. (default: :obj:`0`)
      add_self_loops (bool, optional): If set to :obj:`False`, will not add
          self-loops to the input graph. (default: :obj:`True`)
      edge_dim (int, optional): Edge feature dimensionality (in case
          there are any). (default: :obj:`None`)
      fill_value (float or torch.Tensor or str, optional): The way to
          generate edge features of self-loops
          (in case :obj:`edge_dim != None`).
          If given as :obj:`float` or :class:`torch.Tensor`, edge features of
          self-loops will be directly given by :obj:`fill_value`.
          If given as :obj:`str`, edge features of self-loops are computed by
          aggregating all features of edges that point to the specific node,
          according to a reduce operation. (:obj:`"add"`, :obj:`"mean"`,
          :obj:`"min"`, :obj:`"max"`, :obj:`"mul"`). (default: :obj:`"mean"`)
      bias (bool, optional): If set to :obj:`False`, the layer will not learn
          an additive bias. (default: :obj:`True`)
      share_weights (bool, optional): If set to :obj:`True`, the same matrix
          will be applied to the source and the target node of every edge,
          *i.e.* :math:`\mathbf{\Theta}_{s} = \mathbf{\Theta}_{t}`.
          (default: :obj:`False`)
      **kwargs (optional): Additional arguments of
          :class:`torch_geometric.nn.conv.MessagePassing`.
  
  Shapes:
      - **input:**
        node features :math:`(|\mathcal{V}|, F_{in})` or
        :math:`((|\mathcal{V_s}|, F_{s}), (|\mathcal{V_t}|, F_{t}))`
        if bipartite,
        edge indices :math:`(2, |\mathcal{E}|)`,
        edge features :math:`(|\mathcal{E}|, D)` *(optional)*
      - **output:** node features :math:`(|\mathcal{V}|, H * F_{out})` or
        :math:`((|\mathcal{V}_t|, H * F_{out})` if bipartite.
        If :obj:`return_attention_weights=True`, then
        :math:`((|\mathcal{V}|, H * F_{out}),
        ((2, |\mathcal{E}|), (|\mathcal{E}|, H)))`
        or :math:`((|\mathcal{V_t}|, H * F_{out}), ((2, |\mathcal{E}|),
        (|\mathcal{E}|, H)))` if bipartite
code: def __repr__(self) -> str:
      return (
          f"{self.__class__.__name__}({self.in_channels}, "
          f"{self.out_channels}, heads={self.heads})"
      )
  
imports: import typing
  from typing import Optional, Tuple, Union
  import torch
  import torch.nn.functional
  from torch import Tensor
  from torch.nn import Parameter
  from torch_geometric.nn.conv import MessagePassing
  from torch_geometric.nn.dense.linear import Linear
  from torch_geometric.nn.inits import glorot, zeros
  from torch_geometric.typing import Adj, NoneType, OptTensor, PairTensor, SparseTensor, torch_sparse
  from torch_geometric.utils import add_self_loops, is_torch_sparse_tensor, remove_self_loops, softmax
  from torch_geometric.utils.sparse import set_sparse_value
label_desc: Use image node_id 9 for calling the GATv2Conv obj's underlying member method code with example usage: obj.__repr__() and returns: self, str, self, str, self, str, self, str