class_docstr: Dynamic convolution attention from
  https://arxiv.org/pdf/1910.10288.pdf
  
  
  query -> linear -> tanh -> linear ->|
                                      |                                            mask values
                                      v                                              |    |
             atten_w(t-1) -|-> conv1d_dynamic -> linear -|-> tanh -> + -> softmax -> * -> * -> context
                           |-> conv1d_static  -> linear -|           |
                           |-> conv1d_prior   -> log ----------------|
  
  query: attention rnn output.
  
  Note:
      Dynamic convolution attention is an alternation of the location senstive attention with
  dynamically computed convolution filters from the previous attention scores and a set of
  constraints to keep the attention alignment diagonal.
  
  Args:
      query_dim (int): number of channels in the query tensor.
      embedding_dim (int): number of channels in the value tensor.
      static_filter_dim (int): number of channels in the convolution layer computing the static filters.
      static_kernel_size (int): kernel size for the convolution layer computing the static filters.
      dynamic_filter_dim (int): number of channels in the convolution layer computing the dynamic filters.
      dynamic_kernel_size (int): kernel size for the convolution layer computing the dynamic filters.
      prior_filter_len (int, optional): [description]. Defaults to 11 from the paper.
      alpha (float, optional): [description]. Defaults to 0.1 from the paper.
      beta (float, optional): [description]. Defaults to 0.9 from the paper.
code: def __init__(
      self,
      query_dim,
      embedding_dim,  # pylint: disable=unused-argument
      attention_dim,
      static_filter_dim,
      static_kernel_size,
      dynamic_filter_dim,
      dynamic_kernel_size,
      prior_filter_len=11,
      alpha=0.1,
      beta=0.9,
  ):
      super().__init__()
      self._mask_value = 1e-8
      self.dynamic_filter_dim = dynamic_filter_dim
      self.dynamic_kernel_size = dynamic_kernel_size
      self.prior_filter_len = prior_filter_len
      self.attention_weights = None
      # setup key and query layers
      self.query_layer = nn.Linear(query_dim, attention_dim)
      self.key_layer = nn.Linear(
          attention_dim,
          dynamic_filter_dim * dynamic_kernel_size,
          bias=False,
      )
      self.static_filter_conv = nn.Conv1d(
          1,
          static_filter_dim,
          static_kernel_size,
          padding=(static_kernel_size - 1) // 2,
          bias=False,
      )
      self.static_filter_layer = nn.Linear(
          static_filter_dim, attention_dim, bias=False
      )
      self.dynamic_filter_layer = nn.Linear(
          dynamic_filter_dim, attention_dim
      )
      self.v = nn.Linear(attention_dim, 1, bias=False)
  
      prior = betabinom.pmf(
          range(prior_filter_len), prior_filter_len - 1, alpha, beta
      )
      self.register_buffer("prior", torch.FloatTensor(prior).flip(0))
  
imports: import torch
  from torch import nn
  from torch.nn import functional
  from TTS.tts.layers.common_layers import Linear
  from scipy.stats import betabinom
label_desc: Use image node_id 1 to create a new MonotonicDynamicConvolutionAttention object from inherited base classes: nn with example: obj = MonotonicDynamicConvolutionAttention(query_dim, embedding_dim, attention_dim, static_filter_dim, static_kernel_size, dynamic_filter_dim, dynamic_kernel_size, prior_filter_len, alpha, beta)