class_docstr: MultiHeadAttention layer.
  
  This is an implementation of multi-headed attention as described in the
  paper "Attention is all you Need"
  [Vaswani et al., 2017](https://arxiv.org/abs/1706.03762).
  If `query`, `key,` `value` are the same, then
  this is self-attention. Each timestep in `query` attends to the
  corresponding sequence in `key`, and returns a fixed-width vector.
  
  This layer first projects `query`, `key` and `value`. These are
  (effectively) a list of tensors of length `num_attention_heads`, where the
  corresponding shapes are `(batch_size, <query dimensions>, key_dim)`,
  `(batch_size, <key/value dimensions>, key_dim)`,
  `(batch_size, <key/value dimensions>, value_dim)`.
  
  Then, the query and key tensors are dot-producted and scaled. These are
  softmaxed to obtain attention probabilities. The value tensors are then
  interpolated by these probabilities, then concatenated back to a single
  tensor.
  
  Finally, the result tensor with the last dimension as `value_dim` can take
  a linear projection and return.
  
  Args:
      num_heads: Number of attention heads.
      key_dim: Size of each attention head for query and key.
      value_dim: Size of each attention head for value.
      dropout: Dropout probability.
      use_bias: Boolean, whether the dense layers use bias vectors/matrices.
      output_shape: The expected shape of an output tensor, besides the batch
          and sequence dims. If not specified, projects back to the query
          feature dim (the query input's last dimension).
      attention_axes: axes over which the attention is applied. `None` means
          attention over all axes, but batch, heads, and features.
      kernel_initializer: Initializer for dense layer kernels.
      bias_initializer: Initializer for dense layer biases.
      kernel_regularizer: Regularizer for dense layer kernels.
      bias_regularizer: Regularizer for dense layer biases.
      activity_regularizer: Regularizer for dense layer activity.
      kernel_constraint: Constraint for dense layer kernels.
      bias_constraint: Constraint for dense layer kernels.
  
  Call arguments:
      query: Query tensor of shape `(B, T, dim)`, where `B` is the batch size,
          `T` is the target sequence length, and dim is the feature dimension.
      value: Value tensor of shape `(B, S, dim)`, where `B` is the batch size,
          `S` is the source sequence length, and dim is the feature dimension.
      key: Optional key tensor of shape `(B, S, dim)`. If not given, will
          use `value` for both `key` and `value`, which is the most common
          case.
      attention_mask: a boolean mask of shape `(B, T, S)`, that prevents
          attention to certain positions. The boolean mask specifies which
          query elements can attend to which key elements, 1 indicates
          attention and 0 indicates no attention. Broadcasting can happen for
          the missing batch dimensions and the head dimension.
      return_attention_scores: A boolean to indicate whether the output should
          be `(attention_output, attention_scores)` if `True`, or
          `attention_output` if `False`. Defaults to `False`.
      training: Python boolean indicating whether the layer should behave in
          training mode (adding dropout) or in inference mode (no dropout).
          Will go with either using the training mode of the parent
          layer/model, or `False` (inference) if there is no parent layer.
      use_causal_mask: A boolean to indicate whether to apply a causal mask to
          prevent tokens from attending to future tokens (e.g., used in a
          decoder Transformer).
  
  Returns:
      attention_output: The result of the computation, of shape `(B, T, E)`,
          where `T` is for target sequence shapes and `E` is the query input
          last dimension if `output_shape` is `None`. Otherwise, the
          multi-head outputs are projected to the shape specified by
          `output_shape`.
      attention_scores: (Optional) multi-head attention coefficients over
          attention axes.
docstr: Applies Dot-product attention with query, key, value tensors.
  
  This function defines the computation inside `call` with projected
  multi-head Q, K, V inputs. Users can override this function for
  customized attention implementation.
  
  Args:
      query: Projected query tensor of shape `(B, T, N, key_dim)`.
      key: Projected key tensor of shape `(B, S, N, key_dim)`.
      value: Projected value tensor of shape `(B, S, N, value_dim)`.
      attention_mask: a boolean mask of shape `(B, T, S)`, that prevents
          attention to certain positions. It is generally not needed if
          the `query` and `value` (and/or `key`) are masked.
      training: Python boolean indicating whether the layer should behave
          in training mode (adding dropout) or in inference mode (doing
          nothing).
  
  Returns:
    attention_output: Multi-headed outputs of attention computation.
    attention_scores: Multi-headed attention weights.
docstr_tok: ["Applies","Dot-product","attention","with","query",",","key",",","value","tensors",".","This","function","defines","the","computation","inside","`","call","`","with","projected","multi-head","Q",",","K",",","V","inputs",".","Users","can","override","this","function","for","customized","attention","implementation",".","Args",":","query",":","Projected","query","tensor","of","shape","`","(","B",",","T",",","N",",","key_dim",")","`",".","key",":","Projected","key","tensor","of","shape","`","(","B",",","S",",","N",",","key_dim",")","`",".","value",":","Projected","value","tensor","of","shape","`","(","B",",","S",",","N",",","value_dim",")","`",".","attention_mask",":","a","boolean","mask","of","shape","`","(","B",",","T",",","S",")","`",",","that","prevents","attention","to","certain","positions",".","It","is","generally","not","needed","if","the","`","query","`","and","`","value","`","(","and\/or","`","key","`",")","are","masked",".","training",":","Python","boolean","indicating","whether","the","layer","should","behave","in","training","mode","(","adding","dropout",")","or","in","inference","mode","(","doing","nothing",")",".","Returns",":","attention_output",":","Multi-headed","outputs","of","attention","computation",".","attention_scores",":","Multi-headed","attention","weights","."]
code: def _compute_attention(
      self, query, key, value, attention_mask=None, training=None
  ):
      """Applies Dot-product attention with query, key, value tensors.
  
      This function defines the computation inside `call` with projected
      multi-head Q, K, V inputs. Users can override this function for
      customized attention implementation.
  
      Args:
          query: Projected query tensor of shape `(B, T, N, key_dim)`.
          key: Projected key tensor of shape `(B, S, N, key_dim)`.
          value: Projected value tensor of shape `(B, S, N, value_dim)`.
          attention_mask: a boolean mask of shape `(B, T, S)`, that prevents
              attention to certain positions. It is generally not needed if
              the `query` and `value` (and/or `key`) are masked.
          training: Python boolean indicating whether the layer should behave
              in training mode (adding dropout) or in inference mode (doing
              nothing).
  
      Returns:
        attention_output: Multi-headed outputs of attention computation.
        attention_scores: Multi-headed attention weights.
      """
      # Note: Applying scalar multiply at the smaller end of einsum improves
      # XLA performance, but may introduce slight numeric differences in
      # the Transformer attention head.
      query = ops.multiply(
          query, ops.cast(self._inverse_sqrt_key_dim, query.dtype)
      )
  
      # Take the dot product between "query" and "key" to get the raw
      # attention scores.
      attention_scores = ops.einsum(
          self._dot_product_equation, key, query
      )
  
      attention_scores = self._masked_softmax(
          attention_scores, attention_mask
      )
  
      # This is actually dropping out entire tokens to attend to, which might
      # seem a bit unusual, but is taken from the original Transformer paper.
      if self.dropout:
          final_attn_scores = self._dropout_layer(
              attention_scores, training=training
          )
      else:
          final_attn_scores = attention_scores
  
      # `context_layer` = [B, T, N, H]
      attention_output = ops.einsum(
          self._combine_equation, final_attn_scores, value
      )
      return attention_output, attention_scores
  
imports: import collections
  import math
  import string
  import numpy
  from keras import constraints
  from keras import initializers
  from keras import ops
  from keras import regularizers
  from keras.api_export import keras_export
  from keras.layers.activations.softmax import Softmax
  from keras.layers.core.einsum_dense import EinsumDense
  from keras.layers.layer import Layer
  from keras.layers.regularization.dropout import Dropout
label_desc: Use image node_id 19 for calling the MultiHeadAttention obj's underlying member method code with example usage: obj._compute_attention(query, key, value, attention_mask, training) and returns: attention_output,  attention_scores