class_docstr: Global attention takes a matrix and a query vector. It
  then computes a parameterized convex combination of the matrix
  based on the input query.
  
  Constructs a unit mapping a query `q` of size `dim`
  and a source matrix `H` of size `n x dim`, to an output
  of size `dim`.
  
  
  .. mermaid::
  
     graph BT
        A[Query]
        subgraph RNN
          C[H 1]
          D[H 2]
          E[H N]
        end
        F[Attn]
        G[Output]
        A --> F
        C --> F
        D --> F
        E --> F
        C -.-> G
        D -.-> G
        E -.-> G
        F --> G
  
  All models compute the output as
  :math:`c = \sum_{j=1}^{\text{SeqLength}} a_j H_j` where
  :math:`a_j` is the softmax of a score function.
  Then then apply a projection layer to [q, c].
  
  However they
  differ on how they compute the attention score.
  
  * Luong Attention (dot, general):
     * dot: :math:`\text{score}(H_j,q) = H_j^T q`
     * general: :math:`\text{score}(H_j, q) = H_j^T W_a q`
  
  
  * Bahdanau Attention (mlp):
     * :math:`\text{score}(H_j, q) = v_a^T \text{tanh}(W_a q + U_a h_j)`
  
  
  Args:
     dim (int): dimensionality of query and key
     coverage (bool): use coverage term
     attn_type (str): type of attention to use, options [dot,general,mlp]
     attn_func (str): attention function to use, options [softmax,sparsemax]
code: def __init__(
      self, dim, coverage=False, attn_type="dot", attn_func="softmax"
  ):
      super(GlobalAttention, self).__init__()
  
      self.dim = dim
      assert attn_type in [
          "dot",
          "general",
          "mlp",
      ], "Please select a valid attention type (got {:s}).".format(
          attn_type
      )
      self.attn_type = attn_type
      assert attn_func in [
          "softmax",
          "sparsemax",
      ], "Please select a valid attention function."
      self.attn_func = attn_func
  
      if self.attn_type == "general":
          self.linear_in = nn.Linear(dim, dim, bias=False)
      elif self.attn_type == "mlp":
          self.linear_context = nn.Linear(dim, dim, bias=False)
          self.linear_query = nn.Linear(dim, dim, bias=True)
          self.v = nn.Linear(dim, 1, bias=False)
      # mlp wants it with bias
      out_bias = self.attn_type == "mlp"
      self.linear_out = nn.Linear(dim * 2, dim, bias=out_bias)
  
      if coverage:
          self.linear_cover = nn.Linear(1, dim, bias=False)
  
file_path: OpenNMT-py/onmt/modules/global_attention.py
imports: import torch
  import torch.nn
  import torch.nn.functional
  from onmt.modules.sparse_activations import sparsemax
  from onmt.utils.misc import sequence_mask
label_desc: Use image node_id 1 to create a new GlobalAttention object from inherited base classes: nn with example: obj = GlobalAttention(dim, coverage, attn_type, attn_func)