Ë
    (täiT  ã                   ó˜  — d dl Z d dlZd dlmZ d dlZd dlmZ ddl	m
Z
  e
j                  e«      Zddefd„Zej                   j"                  j$                  ddfdedefd	„Z G d
„ dej(                  «      Z G d„ dej(                  «      Z G d„ dej(                  «      Z G d„ dej(                  «      Z G d„ dej(                  «      Zy)é    Né   )Úloggingé   Úkey_chunk_sizec                 óž  ‡ ‡‡‡‡‡‡‡‡— ‰j                   dd \  }ŠŠ‰j                   d   Št        ‰|«      Š‰ t        j                  ‰«      z  Š t	        j
                  t        j                  d¬«      ˆfd„«       Šˆˆˆˆˆ ˆˆˆfd„}t        j                  j                  |t        j                  d|‰«      ¬	«      \  }}}	t        j                  |	dd
¬«      }
t        j                  |	|
z
  «      }|t        j                  |d¬«      z  }||z  }|j                  d¬«      }t        j                  |d«      j                  d¬«      }||z  S )zBMulti-head dot product attention with a limited number of queries.éýÿÿÿNéÿÿÿÿF)Úprevent_csec                 ó\  •— t        j                  d| |‰¬«      }t        j                  |dd¬«      }t        j                  j                  |«      }t        j                  ||z
  «      }t        j                  d||‰¬«      }t        j                  d|«      }||j                  d¬«      |fS )	Nz...qhd,...khd->...qhk)Ú	precisionr	   T©ÚaxisÚkeepdimsz...vhf,...qhv->...qhfz...qhk->...qh©r   )ÚjnpÚeinsumÚmaxÚjaxÚlaxÚstop_gradientÚexpÚsum)ÚqueryÚkeyÚvalueÚattn_weightsÚ	max_scoreÚexp_weightsÚ
exp_valuesr   s          €ún/Volumes/fast/ai/experiments/MLX_z-image/.venv/lib/python3.12/site-packages/diffusers/models/attention_flax.pyÚsummarize_chunkz/_query_chunk_attention.<locals>.summarize_chunk#   s�   ø€ ä—z‘zÐ"9¸5À#ÐQZÔ[ˆä—G‘G˜L¨r¸DÔAˆ	Ü—G‘G×)Ñ)¨)Ó4ˆ	Ü—g‘g˜l¨YÑ6Ó7ˆä—Z‘ZÐ 7¸ÀÐW`Ôaˆ
Ü—J‘J˜°	Ó:ˆ	à˜KŸO™O°˜OÓ4°iÐ@Ð@ó    c           	      ól  •— t         j                  j                  ‰dg‰j                  dz
  z  | ddgz   t	        ‰j
                  d d «      ‰‰‰gz   ¬«      }t         j                  j                  ‰
dg‰
j                  dz
  z  | ddgz   t	        ‰
j
                  d d «      ‰‰‰	gz   ¬«      } ‰‰||«      S )Nr   é   r   ©ÚoperandÚstart_indicesÚslice_sizes)r   r   Údynamic_sliceÚndimÚlistÚshape)Ú	chunk_idxÚ	key_chunkÚvalue_chunkÚ
k_featuresr   r   Ú	num_headsr   r!   Ú
v_featuresr   s      €€€€€€€€r    Úchunk_scannerz-_query_chunk_attention.<locals>.chunk_scanner0   sÇ   ø€ ä—G‘G×)Ñ)ØØ˜# §¡¨A¡Ñ.°)¸QÀÐ1BÑBÜ˜SŸY™Y s¨˜^Ó,°À	È:Ð/VÑVð *ó 
ˆ	ô —g‘g×+Ñ+ØØ˜# §¡¨a¡Ñ0°I¸qÀ!Ð3DÑDÜ˜UŸ[™[¨¨"Ð-Ó.°.À)ÈZÐ1XÑXð ,ó 
ˆñ ˜u i°Ó=Ð=r"   r   )ÚfÚxsTr   r   )r,   Úminr   ÚsqrtÚ	functoolsÚpartialr   Ú
checkpointr   ÚmapÚaranger   r   Úexpand_dimsr   )r   r   r   r   r   Únum_kvr3   Úchunk_valuesÚchunk_weightsÚ	chunk_maxÚ
global_maxÚ	max_diffsÚ
all_valuesÚall_weightsr0   r1   r!   r2   s   `````         @@@@r    Ú_query_chunk_attentionrF      s$  ÿø€ à$'§I¡I¨b¨c NÑ!€FˆI�zØ—‘˜R‘€JÜ˜¨Ó0€NØ”C—H‘H˜ZÓ(Ñ(€Eä×Ñ”s—~‘~°5Ô9ó
Aó :ð
A÷>ó >ô" .1¯W©W¯[©[¸=ÌSÏZÉZÐXYÐ[aÐcqÓMr¨[Ó-sÑ*€L�- ä—‘˜¨°TÔ:€JÜ—‘˜	 JÑ.Ó/€Ià”C—O‘O I°BÔ7Ñ7€LØ�YÑ€Mà×!Ñ! qÐ!Ó)€JÜ—/‘/ -°Ó4×8Ñ8¸aÐ8Ó@€Kà˜Ñ#Ð#r"   i   Úquery_chunk_sizec           	      óú   ‡ ‡‡‡‡‡‡	‡
‡— ‰ j                   dd \  Š
Š	Šˆˆˆ	ˆ
ˆˆˆ ˆˆf	d„}t        j                  j                  |ddt	        j
                  ‰
‰z  «      ¬«      \  }}t        j                  |d¬«      S )a  
    Flax Memory-efficient multi-head dot product attention. https://huggingface.co/papers/2112.05682v2
    https://github.com/AminRezaei0x443/memory-efficient-attention

    Args:
        query (`jnp.ndarray`): (batch..., query_length, head, query_key_depth_per_head)
        key (`jnp.ndarray`): (batch..., key_value_length, head, query_key_depth_per_head)
        value (`jnp.ndarray`): (batch..., key_value_length, head, value_depth_per_head)
        precision (`jax.lax.Precision`, *optional*, defaults to `jax.lax.Precision.HIGHEST`):
            numerical precision for computation
        query_chunk_size (`int`, *optional*, defaults to 1024):
            chunk size to divide query array value must divide query_length equally without remainder
        key_chunk_size (`int`, *optional*, defaults to 4096):
            chunk size to divide key and value array value must divide key_value_length equally without remainder

    Returns:
        (`jnp.ndarray`) with shape of (batch..., query_length, head, value_depth_per_head)
    r   Nc           	      óì   •	— t         j                  j                  ‰	dg‰	j                  dz
  z  | ddgz   t	        ‰	j
                  d d «      t        ‰
‰«      ‰‰gz   ¬«      }| ‰
z   t        |‰‰‰‰¬«      fS )Nr   r$   r   r%   )r   r   r   r   r   )r   r   r)   r*   r+   r,   r6   rF   )r-   Ú_Úquery_chunkr   r   r1   Únum_qr   Ú
q_featuresr   rG   r   s      €€€€€€€€€r    r3   z5jax_memory_efficient_attention.<locals>.chunk_scannerf   s�   ø€ ä—g‘g×+Ñ+ØØ˜3 %§*¡*¨q¡.Ñ1°iÀÀAÐ5FÑFÜ˜UŸ[™[¨¨"Ð-Ó.´#Ð6FÈÓ2NÐPYÐ[eÐ1fÑfð ,ó 
ˆð Ð(Ñ(Ü"Ø! s°%À9Ð]kôð
ð 	
r"   r   )r4   Úinitr5   Úlengthr   )r,   r   r   ÚscanÚmathÚceilr   Úconcatenate)r   r   r   r   rG   r   r3   rJ   Úresr1   rL   rM   s   ``````   @@@r    Újax_memory_efficient_attentionrU   O   sr   ÿø€ ð* $)§;¡;¨r¨sÐ#3Ñ €Eˆ9�j÷
ô 
ô �W‰W�\‰\Ø
ØØÜ�y‰y˜Ð!1Ñ1Ó2ð	 ó �F€A€sô �?‰?˜3 RÔ(Ð(r"   c                   ó²   — e Zd ZU dZeed<   dZeed<   dZeed<   dZe	ed<   d	Z
eed
<   d	Zeed<   ej                  Zej                  ed<   d„ Zd„ Zd„ Zdd„Zy)ÚFlaxAttentiona  
    A Flax multi-head attention module as described in: https://huggingface.co/papers/1706.03762

    Parameters:
        query_dim (:obj:`int`):
            Input hidden states dimension
        heads (:obj:`int`, *optional*, defaults to 8):
            Number of heads
        dim_head (:obj:`int`, *optional*, defaults to 64):
            Hidden states dimension inside each head
        dropout (:obj:`float`, *optional*, defaults to 0.0):
            Dropout rate
        use_memory_efficient_attention (`bool`, *optional*, defaults to `False`):
            enable memory efficient attention https://huggingface.co/papers/2112.05682
        split_head_dim (`bool`, *optional*, defaults to `False`):
            Whether to split the head dimension into a new axis for the self-attention computation. In most cases,
            enabling this flag should speed up the computation for Stable Diffusion 2.x and Stable Diffusion XL.
        dtype (:obj:`jnp.dtype`, *optional*, defaults to jnp.float32):
            Parameters `dtype`

    Ú	query_dimé   Úheadsé@   Údim_headç        ÚdropoutFÚuse_memory_efficient_attentionÚsplit_head_dimÚdtypec                 ó$  — t         j                  d«       | j                  | j                  z  }| j                  dz  | _        t        j                  |d| j                  d¬«      | _        t        j                  |d| j                  d¬«      | _	        t        j                  |d| j                  d¬«      | _
        t        j                  | j                  | j                  d¬	«      | _        t        j                  | j                  ¬
«      | _        y )Nú”Flax classes are deprecated and will be removed in Diffusers v1.0.0. We recommend migrating to PyTorch classes or pinning your version of Diffusers.g      à¿FÚto_q)Úuse_biasra   ÚnameÚto_kÚto_vÚto_out_0)ra   rf   ©Úrate)ÚloggerÚwarningr\   rZ   ÚscaleÚnnÚDensera   r   r   r   rX   Ú	proj_attnÚDropoutr^   Údropout_layer©ÚselfÚ	inner_dims     r    ÚsetupzFlaxAttention.setupž   s»   € Ü�‰ð[ô	
ð
 —M‘M D§J¡JÑ.ˆ	Ø—]‘] DÑ(ˆŒ
ô —X‘X˜i°%¸t¿z¹zÐPVÔWˆŒ
Ü—8‘8˜I°¸T¿Z¹ZÈfÔUˆŒÜ—X‘X˜i°%¸t¿z¹zÐPVÔWˆŒ
äŸ™ $§.¡.¸¿
¹
ÈÔTˆŒÜŸZ™Z¨T¯\©\Ô:ˆÕr"   c                 óÊ   — |j                   \  }}}| j                  }|j                  |||||z  «      }t        j                  |d«      }|j                  ||z  |||z  «      }|S ©N)r   r   é   r$   ©r,   rZ   Úreshaper   Ú	transpose©ru   ÚtensorÚ
batch_sizeÚseq_lenÚdimÚ	head_sizes         r    Úreshape_heads_to_batch_dimz(FlaxAttention.reshape_heads_to_batch_dim¯   se   € Ø#)§<¡<Ñ ˆ
�G˜SØ—J‘Jˆ	Ø—‘ 
¨G°YÀÀyÑ@PÓQˆÜ—‘˜v |Ó4ˆØ—‘ 
¨YÑ 6¸ÀÈ	ÑAQÓRˆØˆr"   c                 óÊ   — |j                   \  }}}| j                  }|j                  ||z  |||«      }t        j                  |d«      }|j                  ||z  |||z  «      }|S ry   r{   r~   s         r    Úreshape_batch_dim_to_headsz(FlaxAttention.reshape_batch_dim_to_heads·   sd   € Ø#)§<¡<Ñ ˆ
�G˜SØ—J‘Jˆ	Ø—‘ 
¨iÑ 7¸ÀGÈSÓQˆÜ—‘˜v |Ó4ˆØ—‘ 
¨iÑ 7¸À#È	Á/ÓRˆØˆr"   Nc                 ó  — |€|n|}| j                  |«      }| j                  |«      }| j                  |«      }| j                  rš|j                  d   }t        j                  ||d| j                  | j                  f«      }t        j                  ||d| j                  | j                  f«      }	t        j                  ||d| j                  | j                  f«      }
n3| j                  |«      }| j                  |«      }	| j                  |«      }
| j                  rÍ|j                  ddd«      }|	j                  ddd«      }	|
j                  ddd«      }
|j                  d   }|dz  dk(  rt        |dz  «      }n9|dz  dk(  rt        |dz  «      }n"|dz  dk(  rt        |dz  «      }nt        |«      }t        ||	|
|d	¬
«      }|j                  ddd«      }| j                  |«      }nú| j                  rt        j                  d|	|«      }nt        j                  d||	«      }|| j                   z  }t#        j$                  || j                  rdnd¬«      }| j                  rWt        j                  d||
«      }|j                  d   }t        j                  ||d| j                  | j                  z  f«      }n(t        j                  d||
«      }| j                  |«      }| j'                  |«      }| j)                  ||¬«      S )Nr   r	   rz   r   r   r[   é   é   i @  )rG   r   zb t n h, b f n h -> b n f tzb i d, b j d->b i jr   zb n f t, b t n h -> b f n hzb i j, b j d -> b i d©Údeterministic)r   r   r   r`   r,   r   r|   rZ   r\   r„   r_   r}   ÚintrU   r†   r   rn   ro   Úsoftmaxrq   rs   )ru   Úhidden_statesÚcontextr‹   Ú
query_projÚkey_projÚ
value_projÚbÚquery_statesÚ
key_statesÚvalue_statesÚflatten_latent_dimrG   Úattention_scoresÚattention_probss                  r    Ú__call__zFlaxAttention.__call__¿   sÜ  € Ø#* ?‘-¸ˆà—Z‘Z Ó.ˆ
Ø—8‘8˜GÓ$ˆØ—Z‘Z Ó(ˆ
à×ÒØ×#Ñ# AÑ&ˆAÜŸ;™; z°A°r¸4¿:¹:ÀtÇ}Á}Ð3UÓVˆLÜŸ™ X°°2°t·z±zÀ4Ç=Á=Ð/QÓRˆJÜŸ;™; z°A°r¸4¿:¹:ÀtÇ}Á}Ð3UÓV‰Là×:Ñ:¸:ÓFˆLØ×8Ñ8¸ÓBˆJØ×:Ñ:¸:ÓFˆLà×.Ò.Ø'×1Ñ1°!°Q¸Ó:ˆLØ#×-Ñ-¨a°°AÓ6ˆJØ'×1Ñ1°!°Q¸Ó:ˆLð
 ".×!3Ñ!3°BÑ!7ÐØ! BÑ&¨!Ò+Ü#&Ð'9¸BÑ'>Ó#?Ñ Ø# bÑ(¨AÒ-Ü#&Ð'9¸BÑ'>Ó#?Ñ Ø# aÑ'¨1Ò,Ü#&Ð'9¸AÑ'=Ó#>Ñ ä#&Ð'9Ó#:Ð ä:Ø˜j¨,ÐIYÐjrôˆMð *×3Ñ3°A°q¸!Ó<ˆMØ ×;Ñ;¸MÓJ‰Mð ×"Ò"Ü#&§:¡:Ð.KÈZÐYeÓ#fÑ ä#&§:¡:Ð.CÀ\ÐS]Ó#^Ð à/°$·*±*Ñ<ÐÜ Ÿj™jÐ)9Àd×FYÒFYÁÐ_`ÔaˆOð ×"Ò"Ü #§
¡
Ð+HÈ/Ð[gÓ h�Ø!×'Ñ'¨Ñ*�Ü #§¡¨M¸A¸rÀ4Ç:Á:ÐPT×P]ÑP]ÑC]Ð;^Ó _‘ä #§
¡
Ð+BÀOÐUaÓ b�Ø $× ?Ñ ?ÀÓ N�àŸ™ }Ó5ˆØ×!Ñ! -¸}Ð!ÓMÐMr"   )NT)Ú__name__Ú
__module__Ú__qualname__Ú__doc__rŒ   Ú__annotations__rZ   r\   r^   Úfloatr_   Úboolr`   r   Úfloat32ra   rw   r„   r†   rš   © r"   r    rW   rW      sg   … ñð, ƒNØ€Eˆ3ƒNØ€HˆcÓØ€GˆUÓØ+0Ð" DÓ0Ø €N�DÓ Ø—{‘{€Eˆ3�9‰9Ó"ò;ò"òô<Nr"   rW   c                   ó¬   — e Zd ZU dZeed<   eed<   eed<   dZeed<   dZe	ed<   e
j                  Ze
j                  ed	<   dZe	ed
<   dZe	ed<   d„ Zdd„Zy)ÚFlaxBasicTransformerBlockau  
    A Flax transformer block layer with `GLU` (Gated Linear Unit) activation function as described in:
    https://huggingface.co/papers/1706.03762


    Parameters:
        dim (:obj:`int`):
            Inner hidden states dimension
        n_heads (:obj:`int`):
            Number of heads
        d_head (:obj:`int`):
            Hidden states dimension inside each head
        dropout (:obj:`float`, *optional*, defaults to 0.0):
            Dropout rate
        only_cross_attention (`bool`, defaults to `False`):
            Whether to only apply cross attention.
        dtype (:obj:`jnp.dtype`, *optional*, defaults to jnp.float32):
            Parameters `dtype`
        use_memory_efficient_attention (`bool`, *optional*, defaults to `False`):
            enable memory efficient attention https://huggingface.co/papers/2112.05682
        split_head_dim (`bool`, *optional*, defaults to `False`):
            Whether to split the head dimension into a new axis for the self-attention computation. In most cases,
            enabling this flag should speed up the computation for Stable Diffusion 2.x and Stable Diffusion XL.
    r‚   Ún_headsÚd_headr]   r^   FÚonly_cross_attentionra   r_   r`   c           	      ó2  — t         j                  d«       t        | j                  | j                  | j
                  | j                  | j                  | j                  | j                  ¬«      | _
        t        | j                  | j                  | j
                  | j                  | j                  | j                  | j                  ¬«      | _        t        | j                  | j                  | j                  ¬«      | _        t        j                  d| j                  ¬«      | _        t        j                  d| j                  ¬«      | _        t        j                  d| j                  ¬«      | _        t        j&                  | j                  ¬«      | _        y )Nrc   ©ra   )r‚   r^   ra   çñhãˆµøä>)Úepsilonra   rj   )rl   rm   rW   r‚   r¦   r§   r^   r_   r`   ra   Úattn1Úattn2ÚFlaxFeedForwardÚffro   Ú	LayerNormÚnorm1Únorm2Únorm3rr   rs   ©ru   s    r    rw   zFlaxBasicTransformerBlock.setup!  s  € Ü�‰ð[ô	
ô #Ø�H‰HØ�L‰LØ�K‰KØ�L‰LØ×/Ñ/Ø×ÑØ—*‘*ô
ˆŒ
ô #Ø�H‰HØ�L‰LØ�K‰KØ�L‰LØ×/Ñ/Ø×ÑØ—*‘*ô
ˆŒ
ô " d§h¡h¸¿¹ÈDÏJÉJÔWˆŒÜ—\‘\¨$°d·j±jÔAˆŒ
Ü—\‘\¨$°d·j±jÔAˆŒ
Ü—\‘\¨$°d·j±jÔAˆŒ
ÜŸZ™Z¨T¯\©\Ô:ˆÕr"   c                 ó€  — |}| j                   r$| j                  | j                  |«      ||¬«      }n"| j                  | j                  |«      |¬«      }||z   }|}| j                  | j	                  |«      ||¬«      }||z   }|}| j                  | j                  |«      |¬«      }||z   }| j                  ||¬«      S ©NrŠ   )r¨   r­   r²   r®   r³   r°   r´   rs   )ru   rŽ   r�   r‹   Úresiduals        r    rš   z"FlaxBasicTransformerBlock.__call__A  sÅ   € à ˆØ×$Ò$Ø ŸJ™J t§z¡z°-Ó'@À'ÐYf˜JÓg‰Mà ŸJ™J t§z¡z°-Ó'@ÐP]˜JÓ^ˆMØ%¨Ñ0ˆð !ˆØŸ
™
 4§:¡:¨mÓ#<¸gÐUb˜
ÓcˆØ%¨Ñ0ˆð !ˆØŸ™ §
¡
¨=Ó 9È˜ÓWˆØ%¨Ñ0ˆà×!Ñ! -¸}Ð!ÓMÐMr"   N©T)r›   rœ   r�   rž   rŒ   rŸ   r^   r    r¨   r¡   r   r¢   ra   r_   r`   rw   rš   r£   r"   r    r¥   r¥   þ   s`   … ñð2 
ƒHØƒLØƒKØ€GˆUÓØ!&Ð˜$Ó&Ø—{‘{€Eˆ3�9‰9Ó"Ø+0Ð" DÓ0Ø €N�DÓ ò;ô@Nr"   r¥   c                   óÈ   — e Zd ZU dZeed<   eed<   eed<   dZeed<   dZeed<   d	Z	e
ed
<   d	Ze
ed<   ej                  Zej                  ed<   d	Ze
ed<   d	Ze
ed<   d„ Zdd„Zy)ÚFlaxTransformer2DModelaå  
    A Spatial Transformer layer with Gated Linear Unit (GLU) activation function as described in:
    https://huggingface.co/papers/1506.02025


    Parameters:
        in_channels (:obj:`int`):
            Input number of channels
        n_heads (:obj:`int`):
            Number of heads
        d_head (:obj:`int`):
            Hidden states dimension inside each head
        depth (:obj:`int`, *optional*, defaults to 1):
            Number of transformers block
        dropout (:obj:`float`, *optional*, defaults to 0.0):
            Dropout rate
        use_linear_projection (`bool`, defaults to `False`): tbd
        only_cross_attention (`bool`, defaults to `False`): tbd
        dtype (:obj:`jnp.dtype`, *optional*, defaults to jnp.float32):
            Parameters `dtype`
        use_memory_efficient_attention (`bool`, *optional*, defaults to `False`):
            enable memory efficient attention https://huggingface.co/papers/2112.05682
        split_head_dim (`bool`, *optional*, defaults to `False`):
            Whether to split the head dimension into a new axis for the self-attention computation. In most cases,
            enabling this flag should speed up the computation for Stable Diffusion 2.x and Stable Diffusion XL.
    Úin_channelsr¦   r§   rz   Údepthr]   r^   FÚuse_linear_projectionr¨   ra   r_   r`   c                 óZ  — t         j                  d«       t        j                  dd¬«      | _        | j
                  | j                  z  }| j                  r't        j                  || j                  ¬«      | _
        n)t        j                  |ddd| j                  ¬«      | _
        t        | j                  «      D �cg c][  }t        || j
                  | j                  | j                  | j                   | j                  | j"                  | j$                  ¬	«      ‘Œ] c}| _        | j                  r't        j                  || j                  ¬«      | _        n)t        j                  |ddd| j                  ¬«      | _        t        j*                  | j                  ¬
«      | _        y c c}w )Nrc   é    r«   )Ú
num_groupsr¬   rª   )rz   rz   ÚVALID)Úkernel_sizeÚstridesÚpaddingra   )r^   r¨   ra   r_   r`   rj   )rl   rm   ro   Ú	GroupNormÚnormr¦   r§   r¾   rp   ra   Úproj_inÚConvÚranger½   r¥   r^   r¨   r_   r`   Útransformer_blocksÚproj_outrr   rs   )ru   rv   rJ   s      r    rw   zFlaxTransformer2DModel.setup~  sJ  € Ü�‰ð[ô	
ô
 —L‘L¨B¸Ô=ˆŒ	à—L‘L 4§;¡;Ñ.ˆ	Ø×%Ò%ÜŸ8™8 I°T·Z±ZÔ@ˆD�LäŸ7™7ØØ"ØØØ—j‘jôˆDŒLô& ˜4Ÿ:™:Ô&ó#
ñ '�ô &ØØ—‘Ø—‘ØŸ™Ø%)×%>Ñ%>Ø—j‘jØ/3×/RÑ/RØ#×2Ñ2ö	ð 'ñ#
ˆÔð ×%Ò%ÜŸH™H Y°d·j±jÔAˆD�MäŸG™GØØ"ØØØ—j‘jôˆDŒMô  ŸZ™Z¨T¯\©\Ô:ˆÕùò3#
s   Â>A F(c                 ó  — |j                   \  }}}}|}| j                  |«      }| j                  r(|j                  |||z  |«      }| j	                  |«      }n'| j	                  |«      }|j                  |||z  |«      }| j
                  D ]  }	 |	|||¬«      }Œ | j                  r&| j                  |«      }|j                  ||||«      }n%|j                  ||||«      }| j                  |«      }||z   }| j                  ||¬«      S r·   )r,   rÇ   r¾   r|   rÈ   rË   rÌ   rs   )
ru   rŽ   r�   r‹   ÚbatchÚheightÚwidthÚchannelsr¸   Útransformer_blocks
             r    rš   zFlaxTransformer2DModel.__call__­  s  € Ø)6×)<Ñ)<Ñ&ˆˆv�u˜hØ ˆØŸ	™	 -Ó0ˆØ×%Ò%Ø)×1Ñ1°%¸À%¹ÈÓRˆMØ ŸL™L¨Ó7‰Mà ŸL™L¨Ó7ˆMØ)×1Ñ1°%¸À%¹ÈÓRˆMà!%×!8Ô!8ÐÙ-¨m¸WÐTaÔb‰Mð "9ð ×%Ò%Ø ŸM™M¨-Ó8ˆMØ)×1Ñ1°%¸ÀÈÓQ‰Mà)×1Ñ1°%¸ÀÈÓQˆMØ ŸM™M¨-Ó8ˆMà%¨Ñ0ˆØ×!Ñ! -¸}Ð!ÓMÐMr"   Nr¹   )r›   rœ   r�   rž   rŒ   rŸ   r½   r^   r    r¾   r¡   r¨   r   r¢   ra   r_   r`   rw   rš   r£   r"   r    r»   r»   W  su   … ñð6 ÓØƒLØƒKØ€Eˆ3ƒNØ€GˆUÓØ"'Ð˜4Ó'Ø!&Ð˜$Ó&Ø—{‘{€Eˆ3�9‰9Ó"Ø+0Ð" DÓ0Ø €N�DÓ ò-;ô^Nr"   r»   c                   ón   — e Zd ZU dZeed<   dZeed<   ej                  Z
ej                  ed<   d„ Zd	d„Zy)
r¯   a½  
    Flax module that encapsulates two Linear layers separated by a non-linearity. It is the counterpart of PyTorch's
    [`FeedForward`] class, with the following simplifications:
    - The activation function is currently hardcoded to a gated linear unit from:
    https://huggingface.co/papers/2002.05202
    - `dim_out` is equal to `dim`.
    - The number of hidden dimensions is hardcoded to `dim * 4` in [`FlaxGELU`].

    Parameters:
        dim (:obj:`int`):
            Inner hidden states dimension
        dropout (:obj:`float`, *optional*, defaults to 0.0):
            Dropout rate
        dtype (:obj:`jnp.dtype`, *optional*, defaults to jnp.float32):
            Parameters `dtype`
    r‚   r]   r^   ra   c                 óî   — t         j                  d«       t        | j                  | j                  | j
                  «      | _        t        j                  | j                  | j
                  ¬«      | _	        y )Nrc   rª   )
rl   rm   Ú	FlaxGEGLUr‚   r^   ra   Únet_0ro   rp   Únet_2rµ   s    r    rw   zFlaxFeedForward.setupÜ  sL   € Ü�‰ð[ô	
ô ˜tŸx™x¨¯©°t·z±zÓBˆŒ
Ü—X‘X˜dŸh™h¨d¯j©jÔ9ˆ�
r"   c                 óN   — | j                  ||¬«      }| j                  |«      }|S r·   )rÖ   r×   )ru   rŽ   r‹   s      r    rš   zFlaxFeedForward.__call__ç  s(   € ØŸ
™
 =À˜
ÓNˆØŸ
™
 =Ó1ˆØÐr"   Nr¹   ©r›   rœ   r�   rž   rŒ   rŸ   r^   r    r   r¢   ra   rw   rš   r£   r"   r    r¯   r¯   Æ  s4   … ñð" 
ƒHØ€GˆUÓØ—{‘{€Eˆ3�9‰9Ó"ò	:ôr"   r¯   c                   ón   — e Zd ZU dZeed<   dZeed<   ej                  Z
ej                  ed<   d„ Zd	d„Zy)
rÕ   a¸  
    Flax implementation of a Linear layer followed by the variant of the gated linear unit activation function from
    https://huggingface.co/papers/2002.05202.

    Parameters:
        dim (:obj:`int`):
            Input hidden states dimension
        dropout (:obj:`float`, *optional*, defaults to 0.0):
            Dropout rate
        dtype (:obj:`jnp.dtype`, *optional*, defaults to jnp.float32):
            Parameters `dtype`
    r‚   r]   r^   ra   c                 óè   — t         j                  d«       | j                  dz  }t        j                  |dz  | j
                  ¬«      | _        t        j                  | j                  ¬«      | _	        y )Nrc   r‰   r   rª   rj   )
rl   rm   r‚   ro   rp   ra   Úprojrr   r^   rs   rt   s     r    rw   zFlaxGEGLU.setupÿ  sR   € Ü�‰ð[ô	
ð
 —H‘H˜q‘Lˆ	Ü—H‘H˜Y¨™]°$·*±*Ô=ˆŒ	ÜŸZ™Z¨T¯\©\Ô:ˆÕr"   c                 ó¬   — | j                  |«      }t        j                  |dd¬«      \  }}| j                  |t	        j
                  |«      z  |¬«      S )Nr   r   rŠ   )rÜ   r   Úsplitrs   ro   Úgelu)ru   rŽ   r‹   Úhidden_linearÚhidden_gelus        r    rš   zFlaxGEGLU.__call__	  sL   € ØŸ	™	 -Ó0ˆÜ%(§Y¡Y¨}¸aÀaÔ%HÑ"ˆ�{Ø×!Ñ! -´"·'±'¸+Ó2FÑ"FÐVcÐ!ÓdÐdr"   Nr¹   rÙ   r£   r"   r    rÕ   rÕ   í  s5   … ñð 
ƒHØ€GˆUÓØ—{‘{€Eˆ3�9‰9Ó"ò;ôer"   rÕ   )r   )r8   rQ   Ú
flax.linenÚlinenro   r   Ú	jax.numpyÚnumpyr   Úutilsr   Ú
get_loggerr›   rl   rŒ   rF   r   Ú	PrecisionÚHIGHESTrU   ÚModulerW   r¥   r»   r¯   rÕ   r£   r"   r    Ú<module>rë      sÍ   ðó Û å Û 
Ý å ð 
ˆ×	Ñ	˜HÓ	%€ñ0$Èó 0$ðh "%§¡×!2Ñ!2×!:Ñ!:ÐTXÐptñ-)ØNQð-)Øjmó-)ô`|N�B—I‘Iô |Nô~VN §	¡	ô VNôrlN˜RŸY™Yô lNô^$�b—i‘iô $ôNe�—	‘	õ er"   