o i e&v@sdZddlZddlZddlZddlZddlmmZ ddl m Z ddl m Z ddl m Z ddlmZddlmZddlmZdd lmZdd lmZdd lmZdd lmZejZd dZddZddZedGdddeZ dS)z'Keras-based multi-head attention layer.N) constraints) initializers) regularizers)Layer) activation)core)regularization)tf_utils) tf_logging) keras_exportc std|ttt|||df}|}dt|D]}||vs)||dkr0|7qt|7|d7}qdfdd|Dfdd|Dfdd|D}d|f}t|}d|f}|||fS) aBuilds einsum equations for the attention computation. Query, key, value inputs after projection are expected to have the shape as: `(bs, , , num_heads, channels)`. `bs` and `` are treated as ``. The attention operations can be generalized: (1) Query-key dot product: `(, , num_heads, channels), (, , num_heads, channels) -> (, num_heads, , )` (2) Combination: `(, num_heads, , ), (, , num_heads, channels) -> (, , num_heads, channels)` Args: rank: Rank of query, key, value tensors. attn_axes: List/tuple of axes, `[-1, rank)`, that attention will be applied to. Returns: Einsum equations. Ncg|]}|qSr.0itarget_notationr^/var/www/myenv/lib/python3.10/site-packages/keras/src/layers/attention/multi_head_attention.py Oz-_build_attention_equation..crrrrrrrrPrcrrrr)source_notationrrrQrz %s,%s->%s)_CHR_IDXtuplenpdeleterangejoinlen) rank attn_axes batch_dims letter_offsetrproduct_notationdot_product_equationattn_scores_rankcombine_equationr)rrr_build_attention_equation)s8     r(c Csd}d}d}d}d}t|D]}t||} || 7}|| 7}q||7}t|D]}t||} || 7}|| 7}q'||7}t|D]}t||} || 7}|| 7}|| 7}q@|d|d|} | |t|fS)zFBuilds an einsum equation for projections inside multi-head attention.r r,z->)rrr) free_dims bound_dims output_dims input_str kernel_str output_str bias_axesr#rcharequationrrr_build_proj_equationas,         r3cCsdg|t|t|SN)rlist) output_rankknown_last_dimsrrr_get_output_shape~sr8zkeras.layers.MultiHeadAttentioncseZdZdZ            d"fdd Zfd d Zed d Zd#d dZddZ d#ddZ ddZ d#ddZ d$ddZ     d%ddZ d&ddZd#ddZd#d d!ZZS)'MultiHeadAttentionaMultiHeadAttention layer. This is an implementation of multi-headed attention as described in the paper "Attention is all you Need" (Vaswani et al., 2017). 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, , key_dim)`, `(batch_size, , key_dim)`, `(batch_size, , 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 an linear projection and return. When using `MultiHeadAttention` inside a custom layer, the custom layer must implement its own `build()` method and call `MultiHeadAttention`'s `_build_from_signature()` there. This enables weights to be restored correctly when the model is loaded. Examples: Performs 1D cross-attention over two sequence inputs with an attention mask. Returns the additional attention weights over heads. >>> layer = MultiHeadAttention(num_heads=2, key_dim=2) >>> target = tf.keras.Input(shape=[8, 16]) >>> source = tf.keras.Input(shape=[4, 16]) >>> output_tensor, weights = layer(target, source, ... return_attention_scores=True) >>> print(output_tensor.shape) (None, 8, 16) >>> print(weights.shape) (None, 2, 8, 4) Performs 2D self-attention over a 5D input tensor on axes 2 and 3. >>> layer = MultiHeadAttention( ... num_heads=2, key_dim=2, attention_axes=(2, 3)) >>> input_tensor = tf.keras.Input(shape=[5, 3, 4, 16]) >>> output_tensor = layer(input_tensor, input_tensor) >>> print(output_tensor.shape) (None, 5, 3, 4, 16) 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)`. value: Value `Tensor` of shape `(B, S, dim)`. 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. NTglorot_uniformzerosc stjdi|d|_||_||_|r|n||_||_||_||_t ||_ t | |_ t | |_t | |_t | |_t | |_t ||_|dur\t|tjjs\|f|_n||_d|_d\|_|_|_dS)NTF)NNNr)super__init__supports_masking _num_heads_key_dim _value_dim_dropout _use_bias _output_shaperget_kernel_initializer_bias_initializerr_kernel_regularizer_bias_regularizer_activity_regularizerr_kernel_constraint_bias_constraint isinstance collectionsabcSized_attention_axes_built_from_signature _query_shape _key_shape _value_shape)self num_headskey_dim value_dimdropoutuse_bias output_shapeattention_axeskernel_initializerbias_initializerkernel_regularizerbias_regularizeractivity_regularizerkernel_constraintbias_constraintkwargs __class__rrr>s,         zMultiHeadAttention.__init__csid|jd|jd|jd|jd|jd|jd|jdt|j d t|j d t |j d t |j d t |jd t|jdt|jd|jd|jd|j}t}tt|t|S)NrXrYrZr[r\r]r^r_r`rarbrcrdre query_shape key_shape value_shape)r@rArBrCrDrErRr serializerGrHrrIrJrKrrLrMrTrUrVr= get_configdictr5items)rWconfig base_configrgrrrmsV      zMultiHeadAttention.get_configcCs`|d}|d}|d}|di|}d|||fvr'tdt||S|||||S)NrirjrkzOne of dimensions of the input shape is missing. It should have been memorized when the layer was serialized. %s is created without weights.r)poploggingwarningstr_build_from_signature)clsrprirjrklayerrrr from_config1s   zMultiHeadAttention.from_configcCsd|_t|drt|j|_nt||_t|dr#t|j|_nt||_|dur2|j|_nt|dr?t|j|_nt||_t ||jj d}t |ddd\}}}t j |ft|d|j|jg|jrn|nddd||_t |jj dddd\}}}t j |ft|d|j|jg|jr|ndd d||_t |jj dddd\}}}t j |ft|d|j|jg|jr|ndd d||_|||||d |_WddS1swYdS) aBuilds layers and variables. Once the method is called, self._built_from_signature will be set to True. Args: query: Query tensor or TensorShape. value: Value tensor or TensorShape. key: Key tensor or TensorShape. TshapeNr r+r,queryr]r0namekeyvalueattention_output)rShasattrtf TensorShaperzrTrVrUr maybe_init_scoper r3r EinsumDenser8r@rArD_get_common_kwargs_for_sublayer _query_dense _key_denserB _value_dense_build_attention_make_output_dense _output_dense)rWr}rrr*einsum_equationr0r6rrrrvDs~                  "z(MultiHeadAttention._build_from_signaturecCs\t|j|j|j|j|j|jd}|jj |j }|j j |j }||d<||d<|S)N)rarbrcrdredtyper_r`) rnrIrJrKrLrM _dtype_policyrGrhryrmrH)rW common_kwargsr_r`rrrrs" z2MultiHeadAttention._get_common_kwargs_for_sublayercCsz|jrt|jtjjs|jg}n |j}n|jdg}t|dt|d\}}}tj |ft |d||j r5|nd|d|S)a2Builds the output projection matrix. Args: free_dims: Number of free dimensions for einsum equation building. common_kwargs: Common keyword arguments for einsum layer. name: Name for the projection layer. Returns: Projection layer. r{r|r Nr~) rErNrOrPrQrTr3rrrr8rD)rWr*rrr]rr0r6rrrrs"       z%MultiHeadAttention._make_output_densecCs|jdurttd|d|_nt|j|_t||jd\|_|_}tt|t|j|}tj||j d|_ t j |j |j d|_dS)a3Builds multi-head dot-product attention computations. This function builds attributes necessary for `_compute_attention` to customize attention computation to replace the default dot-product attention. Args: rank: the rank of query, key, value tensors. Nr r{)r!)axisr)rater)rRrrr(_dot_product_equation_combine_equationrrSoftmaxr_softmaxrDropoutrC_dropout_layer)rWr r& norm_axesrrrrs&    z#MultiHeadAttention._build_attentioncCsT|dur$t|j dd}tt|jt|jD] }tj||d}q|||S)Nr{r )r)rrRrrzr expand_dimsr)rWattention_scoresattention_maskmask_expansion_axis_rrr_masked_softmaxs z"MultiHeadAttention._masked_softmaxc Cs^t|dtt|j}t|j||}|||}|j ||d}t|j ||}||fS)a&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. g?)training) rmultiplymathsqrtfloatrAeinsumrrrr) rWr}rrrrrattention_scores_dropoutrrrr_compute_attentionsz%MultiHeadAttention._compute_attentionFcCs6|js |j|||d|dur|}t|tj}|r!|} |}t|tj} t|tj} | rI| rItj| | } |j| d}|j| d}n| rU|jt |d}n | r`|jt |d}|j |||||d}| |}| |}||}||||||\} }|| } |rtjj| | d} |r| |fS| S)N)r}rr)rz)rruse_causal_mask)lengths)rSrvrNr RaggedTensornested_row_lengths to_tensorrmaximumbounding_shaperz_compute_attention_maskrrrrr from_tensor)rWr}rrrreturn_attention_scoresrrquery_is_ragged query_lengths key_is_raggedvalue_is_raggedrrrrrrcall#sR          zMultiHeadAttention.callc Cs&t|dd}t|dd}t|dd}d} |dur+t|tj}|ddddtjf} |durLt|tj}|ddtjddf} | durH| n| | @} |durmt|tj}|ddtjddf} | duri| n| | @} |r|||} | dur{| n| | @} | dur|dur| nt|t| @}|S)aComputes the attention mask, using the Keras masks of the inputs. * The `query`'s mask is reshaped from [B, T] to [B, T, 1]. * The `value`'s mask is reshaped from [B, S] to [B, 1, S]. * The `key`'s mask is reshaped from [B, S] to [B, 1, S]. The `key`'s mask is ignored if `key` is `None` or if `key is value`. * If `use_causal_mask=True`, then the causal mask is computed. Its shape is [1, T, S]. All defined masks are merged using a logical AND operation (`&`). In general, if the `query` and `value` are masked, then there is no need to define the `attention_mask`. Args: query: Projected query `Tensor` of shape `(B, T, N, key_dim)`. key: Projected key `Tensor` of shape `(B, T, N, key_dim)`. value: Projected value `Tensor` of shape `(B, T, N, value_dim)`. attention_mask: a boolean mask of shape `(B, T, S)`, that prevents attention to certain positions. 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_mask: a boolean mask of shape `(B, T, S)`, that prevents attention to certain positions, based on the Keras masks of the `query`, `key`, `value`, and `attention_mask` tensors, and the causal mask if `use_causal_mask=True`. _keras_maskN)getattrrcastboolnewaxis_compute_causal_mask) rWr}rrrr query_mask value_maskkey_mask auto_maskmaskrrrrfs0 !   z*MultiHeadAttention._compute_attention_maskcCsHt|d}|dur |nt|d}tjtd||ftjddS)aComputes a causal mask (e.g., for masked self-attention layers). For example, if query and value both contain sequences of length 4, this function returns a boolean `Tensor` equal to: ``` [[[True, False, False, False], [True, True, False, False], [True, True, True, False], [True, True, True, True]]] ``` Args: query: query `Tensor` of shape `(B, T, ...)`. value: value `Tensor` of shape `(B, S, ...)` (optional, defaults to query). Returns: mask: a boolean `Tensor` of shape [1, T, S] containing a lower triangular matrix of shape [T, S]. r Nrr)rrzlinalg band_partonesr)rWr}r q_seq_length v_seq_lengthrrrrs z'MultiHeadAttention._compute_causal_maskcCs|dur|}t|}t|}t|}|d|dkr,td|dd|dd|dd|ddkrBtd|d||jrO|dd|jS|S)NrzMThe last dimension of `query_shape` and `value_shape` must be equal, but are z, z@. Received: query_shape={query_shape}, value_shape={value_shape}r zRAll dimensions of `value` and `key`, except the last one, must be equal. Received z and )rr ValueErrorrE concatenate)rWrirkrjrrrcompute_output_shapes0   z'MultiHeadAttention.compute_output_shape) Nr:TNNr;r<NNNNNr4)NN)NNFNF)NNF)__name__ __module__ __qualname____doc__r>rm classmethodryrvrrrrrrrrr __classcell__rrrgrr9sFj *  O   2 D @r9)!rrOrstringnumpyrtensorflow.compat.v2compatv2r keras.srcrrrkeras.src.engine.base_layerrkeras.src.layersrrrkeras.src.utilsr tensorflow.python.platformr rs tensorflow.python.util.tf_exportr ascii_lowercaserr(r3r8r9rrrrs,          8