
    ^j!                       d Z ddlZddlZddlmZ ddlmZ ddlmZ ddl	Z	ddl
mc mZ ddl	mZ ddlmZ dd	lmZ dd
lmZ ddlmZ ddlmZmZ ddlmZmZ ddlmZ ddlm Z  ddl!m"Z"m#Z#m$Z$m%Z%m&Z&m'Z' ddl(m)Z) ddl*m+Z+ ddl,m-Z-m.Z.m/Z/  e&j`                  e1      Z2d Z3d Z4d Z5de	jl                  de	jl                  fdZ7 e$d      e G d de"                    Z8 e$d      e G d  d!e"                    Z9e$e G d" d#e"                    Z: G d$ d%ejv                        Z< G d& d'ejv                        Z= G d( d)ejv                        Z> G d* d+ejv                        Z? G d, d-ejv                        Z@ G d. d/ejv                        ZA G d0 d1ejv                        ZB G d2 d3ejv                        ZC G d4 d5ejv                        ZD G d6 d7e      ZE G d8 d9ejv                        ZF G d: d;ejv                        ZG G d< d=ejv                        ZH G d> d?ejv                        ZI	 dfd@ejv                  dAe	jl                  dBe	jl                  dCe	jl                  dDe	jl                  dz  dEeJdFeJfdGZK G dH dIejv                        ZL G dJ dKejv                        ZM G dL dMejv                        ZN G dN dOejv                        ZO G dP dQejv                        ZP G dR dSe      ZQ G dT dUejv                        ZR G dV dWejv                        ZSe$ G dX dYe             ZT G dZ d[eT      ZU e$d\       G d] d^eT             ZVe$ G d_ d`eT             ZWe$ G da dbeT             ZXe$ G dc ddeT             ZYg deZZy)gzPyTorch CLAP model.    N)Callable)	dataclass)Any)nn   )initialization)ACT2FN)create_bidirectional_mask)GradientCheckpointingLayer)BaseModelOutputBaseModelOutputWithPooling)ALL_ATTENTION_FUNCTIONSPreTrainedModel)Unpack)apply_chunking_to_forward)ModelOutputTransformersKwargsauto_docstringcan_return_tuplelogging	torch_int)merge_with_config_defaults)capture_outputs   )ClapAudioConfig
ClapConfigClapTextConfigc                     | j                   \  }}}| dddddddf   j                  dd|d      }|j                  |||z  |      }|S )ae  
    Interpolate data in time domain. This is used to compensate the resolution reduction in downsampling of a CNN.

    Args:
        hidden_states (`torch.FloatTensor` of shape (batch_size, time_length, classes_num)):
            Input hidden states
        ratio (`int`):
            The ratio of the length of the output to the length of the input.
    Nr   )shaperepeatreshape)hidden_statesratio
batch_sizetime_lengthclasses_num	upsampleds         q/var/www/ramen.bs-engineer-server.com/venv/lib/python3.12/site-packages/transformers/models/clap/modeling_clap.pyinterpolater)   /   sX     .;-@-@*ZkaD!m,33Aq%CI!!*kE.A;OI    c                     | j                   \  }}}}| j                  |||z  |||z  ||      } | j                  dddddd      j                         j                  d|||      }|S )aR  
    Returns the resized hidden states. The output shape should be `(batch_size * num_windows, window_size, window_size,
    num_channels)`

    Args:
        hidden_states (`torch.FloatTensor` of shape `(batch_size, height, width, num_channels)`):
            Input hidden states
        window_size (`int`):
            Window size
    r   r   r            r   viewpermute
contiguous)r"   window_sizer$   heightwidthnum_channelswindowss          r(   window_partitionr9   @   s}     /<.A.A+J|!&&Fk);8Lk[gM ##Aq!Q15@@BGGKYdfrsGNr*   c                     | j                   d   }| j                  d||z  ||z  |||      } | j                  dddddd      j                         j                  d|||      } | S )a  
    Merges windows to produce higher resolution features.
    Args:
        windows (`torch.FloatTensor` of shape `(num_windows * batch_size, window_size, window_size, num_channels)`):
            Input windows
        window_size (`int`):
            Window size
        height (`int`):
            Height of the resized audio
        width (`int`):
            Width of the resized audio
    r/   r   r   r   r,   r-   r.   r0   )r8   r4   r5   r6   r7   s        r(   window_reverser;   U   sn     ==$Lll2v4e{6JKYdfrsGooaAq!Q/::<AA"feUabGNr*   logitsreturnc                     t        j                  t        |       | j                        }t        j
                  j                  | |      S )Ndevice)torcharangelenr@   r   
functionalcross_entropy)r<   labelss     r(   contrastive_lossrG   j   s1    \\#f+fmm<F==&&vv66r*   ze
    Base class for text model's outputs that also contains a pooling of the last hidden states.
    )custom_introc                       e Zd ZU dZdZej                  dz  ed<   dZej                  dz  ed<   dZ	e
ej                  df   dz  ed<   dZe
ej                  df   dz  ed<   y)ClapTextModelOutputz
    text_embeds (`torch.FloatTensor` of shape `(batch_size, output_dim)` *optional* returned when model is initialized with `with_projection=True`):
        The text embeddings obtained by applying the projection layer to the pooler_output.
    Ntext_embedslast_hidden_state.r"   
attentions)__name__
__module____qualname____doc__rK   rA   FloatTensor__annotations__rL   r"   tuplerM    r*   r(   rJ   rJ   o   sr    
 -1K""T)026u((4/6:>M5**C/047>7;Je'',-4;r*   rJ   zT
    ClapAudio model output to mimic the output of the original implementation.
    c                       e Zd ZU dZdZej                  dz  ed<   dZej                  dz  ed<   dZ	e
ej                  df   dz  ed<   dZe
ej                  df   dz  ed<   y)ClapAudioModelOutputz
    audio_embeds (`torch.FloatTensor` of shape `(batch_size, hidden_size)`):
        The Audio embeddings obtained by applying the projection layer to the pooler_output.
    Naudio_embedsrL   .r"   rM   )rN   rO   rP   rQ   rX   rA   rR   rS   rL   r"   rT   rM   rU   r*   r(   rW   rW      sr    
 .2L%##d*126u((4/6:>M5**C/047>7;Je'',-4;r*   rW   c                      e Zd ZU dZdZej                  dz  ed<   dZej                  dz  ed<   dZ	ej                  dz  ed<   dZ
ej                  dz  ed<   dZej                  dz  ed<   dZeed<   dZeed	<   d
ee   fdZy)
ClapOutputa  
    loss (`torch.FloatTensor` of shape `(1,)`, *optional*, returned when `return_loss` is `True`):
        Contrastive loss for audio-text similarity.
    logits_per_audio (`torch.FloatTensor` of shape `(audio_batch_size, text_batch_size)`):
        The scaled dot product scores between `audio_embeds` and `text_embeds`. This represents the audio-text
        similarity scores.
    logits_per_text (`torch.FloatTensor` of shape `(text_batch_size, audio_batch_size)`):
        The scaled dot product scores between `text_embeds` and `audio_embeds`. This represents the text-audio
        similarity scores.
    text_embeds (`torch.FloatTensor` of shape `(batch_size, output_dim`):
        The text embeddings obtained by applying the projection layer to the pooled output of [`ClapTextModel`].
    audio_embeds (`torch.FloatTensor` of shape `(batch_size, output_dim`):
        The audio embeddings obtained by applying the projection layer to the pooled output of [`ClapAudioModel`].
    text_model_output (`BaseModelOutputWithPooling`):
        The output of the [`ClapTextModel`].
    audio_model_output (`BaseModelOutputWithPooling`):
        The output of the [`ClapAudioModel`].
    Nlosslogits_per_audiologits_per_textrK   rX   text_model_outputaudio_model_outputr=   c                 B    t        d | j                         D              S )Nc              3   `   K   | ]&  }t        |t              r|j                         n| ( y wN)
isinstancer   to_tuple).0vs     r(   	<genexpr>z&ClapOutput.to_tuple.<locals>.<genexpr>   s$     ^1Z;%?QZZ\QF^s   ,.)rT   valuesselfs    r(   rd   zClapOutput.to_tuple   s    ^PTP[P[P]^^^r*   )rN   rO   rP   rQ   r[   rA   rR   rS   r\   r]   rK   rX   r^   r   r_   rT   r   rd   rU   r*   r(   rZ   rZ      s    & &*D%

d
")15e''$.504OU&&-4,0K""T)0-1L%##d*148185929_%* _r*   rZ   c                   .     e Zd ZdZdef fdZd Z xZS )ClapAudioAFFBlockz
    ATTENTIONAL FEATURE FUSION Block from CLAP, since in CLAP we are always in 2D mode, it is not needed to implement
    the 1D version.
    configc                    t         |           |j                  }|j                  }t	        ||z        }t        j                  t        j                  ||ddd      t        j                  |      t        j                  d      t        j                  ||ddd      t        j                  |            | _
        t        j                  t        j                  d      t        j                  ||ddd      t        j                  |      t        j                  d      t        j                  ||ddd      t        j                  |            | _        t        j                         | _        y )Nr   r   kernel_sizestridepaddingT)inplace)super__init__patch_embeds_hidden_sizeaff_block_rintr   
SequentialConv2dBatchNorm2dReLU	local_attAdaptiveAvgPool2d
global_attSigmoidsigmoid)rj   rm   channelsdownsize_ratiointer_channels	__class__s        r(   ru   zClapAudioAFFBlock.__init__   s   22++X78IIhAaQRSNN>*GGD!IInhAaQRSNN8$
 --  #IIhAaQRSNN>*GGD!IInhAaQRSNN8$
 zz|r*   c                     ||z   }| j                  |      | j                  |      z   }| j                  |      }d|z  |z  d|z  d|z
  z  z   }|S )Nr,   r   )r}   r   r   )rj   r"   residualattention_inputfused_layer_outputoutputs         r(   forwardzClapAudioAFFBlock.forward   sb    '(2!^^O<t?__!\\*<=]"%77!h,!N`J`:aar*   rN   rO   rP   rQ   r   ru   r   __classcell__r   s   @r(   rl   rl      s    
$ $0r*   rl   c                   0     e Zd ZdZdef fdZddZ xZS )ClapAudioPatchEmbedz
    This module converts the hidden states reshaped as an image to patch embeddings ready to be passed to the
    Transformer block.
    rm   c                    t         |           t        |j                  t              r|j                  |j                  fn|j                  }t        |j
                  t              r|j
                  |j
                  fn|j
                  }t        |j                  t              r|j                  |j                  fn|j                  }|| _        || _        |d   |d   z  |d   |d   z  f| _        | j                  d   | j                  d   z  | _	        |j                  | _        |j                  | _        |d   |d   z
  dz  |d   |d   z
  dz  f}| j                  r|j                  dk(  rdnd}t        j                  |j                   |z  |j"                  |||      | _        |j&                  rt        j(                  |j"                        nt        j*                         | _        | j                  rZt/        |      | _        t        j                  |j                   |j"                  |d   |d   dz  f|d   |d   dz  f|      | _        y y )Nr   r   r,   channel_mapr-   ro   r   )rt   ru   rc   	spec_sizerx   
patch_sizepatch_strideimg_size	grid_sizenum_patchesflatten_patch_embedsflattenenable_fusionfusion_typer   rz   patch_embed_input_channelsrv   projenable_patch_layer_norm	LayerNormIdentitynormrl   fusion_model
mel_conv2d)rj   rm   r   r   r   rr   scale_factorr   s          r(   ru   zClapAudioPatchEmbed.__init__   s+   ;EfFVFVX[;\F$$f&6&67bhbrbr6@ARARTW6XV 1 12^d^o^o 	 ;EVEXEXZ]:^V  &"5"56djdwdw 	 !("1+a8(1+VW:XY>>!,t~~a/@@22#11qMLO39JqMLYZO<[`a;ab ..63E3E3Vq\]II--<++"
	 FLEcEcBLL!@!@Aikititiv	 1& 9D ii11//']JqMA,=>$Qa1)<=DO r*   c                    | j                   r|d d ddd d d d f   }|j                  \  }}}}|| j                  d   k7  s|| j                  d   k7  r2t        d| d| d| j                  d    d| j                  d    d	      | j	                  |      }|j                  d      }t        |      dkD  r||dd d d d d f   j                         }	|	j                  \  }}}}|	j                  ||z  d||      }	| j                  |	      }	|	j                  \  }
}}}|	j                  |||||      }	|	j                  d      j                         j                  d	      }	|	j                  d      }t        j                  j                  j                  |	d||z
  fd
d      }	| j!                  ||   |	      ||<   |}nx|j                  \  }
}
}}|| j                  d   k7  s|| j                  d   k7  r2t        d| d| d| j                  d    d| j                  d    d	      | j	                  |      }| j                  r!|j                  d      j#                  dd      }| j%                  |      }|S )Nr   r   zInput audio size (*z) doesn't match model (z).r/   )r   r,   r   r   r-   r   constantr,   )r   r   r   
ValueErrorr   sizerC   r3   r1   r   r2   r   rA   r   rD   padr   	transposer   )rj   r"   is_longer_idxglobal_hidden_statesr$   r7   r5   r6   output_widthlocal_hidden_states_featureslocal_widths                r(   r   zClapAudioPatchEmbed.forward  s   #0AaCA#>  7K6P6P3Jfeq))UdmmA6F-F (%8OPTP]P]^_P`Oaabcgcpcpqrcsbttvw  $(99-A#B /44R8L=!A%&3M12q!4K&L&W&W&Y#:M:S:S7
L&%&9&>&>zL?XZ[]cej&k#&*oo6I&J#-@-F-F*8VU&9&>&>z<Yacikp&q#&9&A&A/&R&]&]&_&g&ghi&j#166r:&+hh&9&9&=&='!\K-G)H*VW'# 7;6G6G(79L7$]3 1M"/"5"5Aq&%q))UdmmA6F-F (%8OPTP]P]^_P`Oaabcgcpcpqrcsbttvw  !IIm4M<<)11!4>>q!DM		-0r*   rb   r   r   s   @r(   r   r      s    
( (T/r*   r   c            
            e Zd Z fdZ	 	 d	dej
                  dej                  dz  dedz  deej
                     fdZ	d Z
 xZS )
ClapAudioSelfAttentionc                    t         |           ||z  dk7  rt        d| d| d      || _        t	        ||z        | _        | j                  | j
                  z  | _        t        |t        j                  j                        r|n||f| _        t        j                  t        j                  d| j                  d   z  dz
  d| j                  d   z  dz
  z  |            | _        | j#                  d| j%                                t        j&                  | j                  | j                  |j(                        | _        t        j&                  | j                  | j                  |j(                        | _        t        j&                  | j                  | j                  |j(                        | _        t        j0                  |j2                        | _        y )	Nr   The hidden size (6) is not a multiple of the number of attention heads ()r,   r   relative_position_indexbias)rt   ru   r   num_attention_headsrx   attention_head_sizeall_head_sizerc   collectionsabcIterabler4   r   	ParameterrA   zerosrelative_position_bias_tableregister_buffercreate_relative_position_indexLinearqkv_biasquerykeyvalueDropoutattention_probs_dropout_probdropoutrj   rm   dim	num_headsr4   r   s        r(   ru   zClapAudioSelfAttention.__init__D  s   ?a#C5(^_h^iijk  $- #&sY#7 !558P8PP%k;??3K3KLKS^`kRl 	 -/LLKKT--a0014T=M=Ma=P9PST9TUW`a-
) 	68[8[8]^YYt1143E3EFOO\
99T//1C1C&//ZYYt1143E3EFOO\
zz&"E"EFr*   Nr"   attention_maskoutput_attentionsr=   c                    |j                   \  }}}||d| j                  f}| j                  |      j                  |      j	                  dd      }| j                  |      j                  |      j	                  dd      }	| j                  |      j                  |      j	                  dd      }
t        j                  ||	j	                  dd            }|t        j                  | j                        z  }| j                  | j                  j                  d         }|j                  | j                  d   | j                  d   z  | j                  d   | j                  d   z  d      }|j                  ddd      j                         }||j!                  d      z   }|r|j                   d   }|j                  ||z  || j"                  ||      }||j!                  d      j!                  d      z   }|j                  d| j"                  ||      }t$        j&                  j)                  |d      }| j+                  |      }t        j                  ||
      }|j                  dddd      j                         }|j-                         d d | j.                  fz   }|j                  |      }|r||f}|S |f}|S )Nr/   r   r,   r   r   r   )r   r   r   r1   r   r   r   rA   matmulmathsqrtr   r   r4   r2   r3   	unsqueezer   r   rD   softmaxr   r   r   )rj   r"   r   r   r$   r   r7   hidden_shapequery_layer	key_layervalue_layerattention_scoresrelative_position_bias
mask_shapeattention_probscontext_layernew_context_layer_shapeoutputss                     r(   r   zClapAudioSelfAttention.forward^  s    )6(;(;%
C"CT-E-EFjj/44\BLLQPQRHH]+00>HHAN	jj/44\BLLQPQR !<<Y5H5HR5PQ+dii8P8P.QQ!%!B!B4C_C_CdCdegCh!i!7!<!<Q$"2"21"55t7G7G7JTM]M]^_M`7`bd"
 "8!?!?1a!H!S!S!U+.D.N.Nq.QQ%'--a0J/44j(*d6N6NPSUX   0.2J2J12M2W2WXY2ZZ/44R9Q9QSVX[\ --//0@b/I ,,7_kB%--aAq9DDF"/"4"4"6s";t?Q?Q>S"S%**+BC6G=/2 O\M]r*   c                    t        j                  | j                  d         }t        j                  | j                  d         }t        j                  t        j                  ||gd            }t        j
                  |d      }|d d d d d f   |d d d d d f   z
  }|j                  ddd      j                         }|d d d d dfxx   | j                  d   dz
  z  cc<   |d d d d dfxx   | j                  d   dz
  z  cc<   |d d d d dfxx   d| j                  d   z  dz
  z  cc<   |j                  d      }|S )Nr   r   ij)indexingr,   r/   )	rA   rB   r4   stackmeshgridr   r2   r3   sum)rj   coords_hcoords_wcoordscoords_flattenrelative_coordsr   s          r(   r   z5ClapAudioSelfAttention.create_relative_position_index  s-   << 0 0 34<< 0 0 34U^^Xx,@4PQvq1(At4~aqj7QQ)11!Q:EEG1a D$4$4Q$7!$;; 1a D$4$4Q$7!$;; 1a A(8(8(;$;a$?? "1"5"5b"9&&r*   NF)rN   rO   rP   ru   rA   TensorrR   boolrT   r   r   r   r   s   @r(   r   r   C  s^    G: 48).	1||1 ))D01  $;	1
 
u||	1f'r*   r   c                   n     e Zd Z fdZdej
                  dej
                  dej
                  fdZ xZS )ClapAudioSelfOutputc                     t         |           t        j                  ||      | _        t        j
                  |j                        | _        y rb   )rt   ru   r   r   denser   r   r   rj   rm   r   r   s      r(   ru   zClapAudioSelfOutput.__init__  s6    YYsC(
zz&"E"EFr*   r"   input_tensorr=   c                 J    | j                  |      }| j                  |      }|S rb   r   r   rj   r"   r   s      r(   r   zClapAudioSelfOutput.forward  s$    

=1]3r*   rN   rO   rP   ru   rA   r   r   r   r   s   @r(   r   r     s2    G
U\\  RWR^R^ r*   r   c            
            e Zd Z fdZ	 	 ddej
                  dej                  dz  dedz  deej
                     fdZ	 xZ
S )	ClapAudioAttentionc                 j    t         |           t        ||||      | _        t	        ||      | _        y rb   )rt   ru   r   rj   r   r   r   s        r(   ru   zClapAudioAttention.__init__  s.    *63	;O	)&#6r*   Nr"   r   r   r=   c                 h    | j                  |||      }| j                  |d   |      }|f|dd  z   }|S )Nr   r   rj   r   )rj   r"   r   r   self_outputsattention_outputr   s          r(   r   zClapAudioAttention.forward  sE     yy@QR;;|AF#%QR(88r*   r   )rN   rO   rP   ru   rA   r   rR   r   rT   r   r   r   s   @r(   r  r    sW    7 48).		||	 ))D0	  $;		
 
u||		r*   r  c                   V     e Zd Z fdZdej
                  dej
                  fdZ xZS )ClapAudioIntermediatec                    t         |           t        j                  |t	        |j
                  |z              | _        t        |j                  t              rt        |j                     | _        y |j                  | _        y rb   )rt   ru   r   r   rx   	mlp_ratior   rc   
hidden_actstrr	   intermediate_act_fnr   s      r(   ru   zClapAudioIntermediate.__init__  sa    YYsC(8(83(>$?@
f''-'-f.?.?'@D$'-'8'8D$r*   r"   r=   c                 J    | j                  |      }| j                  |      }|S rb   r   r  rj   r"   s     r(   r   zClapAudioIntermediate.forward  &    

=100?r*   r   r   s   @r(   r  r    #    9U\\ ell r*   r  c                   V     e Zd Z fdZdej
                  dej
                  fdZ xZS )ClapAudioOutputc                     t         |           t        j                  t	        |j
                  |z        |      | _        t        j                  |j                        | _	        y rb   )
rt   ru   r   r   rx   r
  r   r   hidden_dropout_probr   r   s      r(   ru   zClapAudioOutput.__init__  sF    YYs6#3#3c#9:C@
zz&"<"<=r*   r"   r=   c                 J    | j                  |      }| j                  |      }|S rb   r   r  s     r(   r   zClapAudioOutput.forward  s$    

=1]3r*   r   r   s   @r(   r  r    s#    >
U\\ ell r*   r  c                   r     e Zd ZdZd	deddf fdZdej                  dej                  fdZde	fdZ
 xZS )
ClapDropPathzStochastic depth (DropPath) per sample, for residual blocks.

    Identity when ``drop_prob`` is 0 or outside training. See `Deep Networks with Stochastic Depth
    <https://arxiv.org/abs/1603.09382>`_.
    	drop_probr=   Nc                 0    t         |           || _        y rb   )rt   ru   r  )rj   r  r   s     r(   ru   zClapDropPath.__init__  s    "r*   r"   c                 P   | j                   dk(  s| j                  s|S d| j                   z
  }|j                  d   fd|j                  dz
  z  z   }t	        j
                  ||j                  |j                        }t	        j                  ||z         }|j                  |      |z  S )N        r   r   )r   dtyper@   )
r  trainingr   ndimrA   randr  r@   floordiv)rj   r"   	keep_probr   random_tensors        r(   r   zClapDropPath.forward  s    >>S   &	$$Q')DM4F4F4J,KK

50C0CML`L`aMI$=>  +m;;r*   c                      d| j                    S )Nzp=)r  ri   s    r(   
extra_reprzClapDropPath.extra_repr  s    DNN#$$r*   r  )rN   rO   rP   rQ   floatru   rA   r   r   r  r(  r   r   s   @r(   r  r    sB    #% #$ #<U\\ <ell <%C %r*   r  c                        e Zd Zd fd	Zd Zd Zd Z	 	 ddej                  de	e
e
f   dedz  d	edz  d
e	ej                  ej                  f   f
dZ xZS )ClapAudioLayerc                    t         |           |j                  | _        || _        |j                  | _        || _        t        j                  ||j                        | _	        t        |||| j                        | _        |dkD  rt        |      nt        j                         | _        t        j                  ||j                        | _        t!        ||      | _        t%        ||      | _        y )Neps)r4   r  )rt   ru   chunk_size_feed_forward
shift_sizer4   input_resolutionr   r   layer_norm_epslayernorm_beforer  	attentionr  r   	drop_pathlayernorm_afterr  intermediater  r   )rj   rm   r   r2  r   drop_path_rater1  r   s          r(   ru   zClapAudioLayer.__init__  s    '-'E'E$$!-- 0 "Sf6K6K L+FCPTP`P`a9G#9Mn5SUS^S^S`!||CV5J5JK1&#>%fc2r*   c                    t        |      | j                  k  rgt        d      | _        t        j
                  j                         r(t	        j                   t	        j                  |            n
t        |      | _        y y Nr   )minr4   r   r1  rA   jit
is_tracingtensor)rj   r2  s     r(   set_shift_and_window_sizez(ClapAudioLayer.set_shift_and_window_size  s\     D$4$44'lDO=BYY=Q=Q=S		%,,'789Y\]mYn  5r*   c                    | j                   dk  ryt        j                  ||      }t        j                  ||      }||| j                  z
  k\  j	                         ||| j                   z
  k\  j	                         z   }||| j                  z
  k\  j	                         ||| j                   z
  k\  j	                         z   }|dddddf   dz  |dddddf   z   j                  |      }	t        |	| j                        }
|
j                  d| j                  | j                  z        }
|
j                  d      |
j                  d      z
  }|j                  |dk7  d      j                  |dk(  d	      }|S )
u  Build the cyclic-shift attention mask for shifted-window MSA; returns None when shift_size is 0.

        Each (h, w) position belongs to one of 9 cyclic-shift regions (3 along each axis), encoded
        as ``h_region * 3 + w_region``. Regions per axis:
        - 0: indices ``[0, axis - window_size)``
        - 1: indices ``[axis - window_size, axis - shift_size)``
        - 2: indices ``[axis - shift_size, axis)``
        Implementation note: a single arithmetic pass on `torch.arange` (two comparisons +
        broadcast add) replaces the original 9-iteration nested-Python-loop slice-assignment —
        fully vectorised, no per-cell host-side scatter, no GPU↔host sync.
        r   Nr?   r   r/   r   r,   g      Yr  )
r1  rA   rB   r4   longtor9   r1   r   masked_fill)rj   r5   r6   r  r@   h_idxw_idxh_regionw_regionimg_maskmask_windows	attn_masks               r(   get_attn_maskzClapAudioLayer.get_attn_mask  si    ??aVF3U62Vd&6&666<<>%6TXTcTcKcBcAiAiAkkUT%5%555;;=%RVRaRaJaAa@g@g@iiT1dD01A5tQPTAT8UUYYZ_`'$2B2BC#((T-=-=@P@P-PQ **1-0F0Fq0II	)))q.&AMMi[\n^ab	r*   c                     | j                   || j                   z  z
  | j                   z  }| j                   || j                   z  z
  | j                   z  }ddd|d|f}t        j                  j                  ||      }||fS r;  )r4   r   rD   r   )rj   r"   r5   r6   	pad_right
pad_bottom
pad_valuess          r(   	maybe_padzClapAudioLayer.maybe_pad'  s    %%0@0@(@@DDTDTT	&&$2B2B)BBdFVFVV
Ay!Z8
))-Dj((r*   r"   input_dimensionsr   Nalways_partitionr=   c                    |s| j                  |       n	 |\  }}|j                         \  }}}	|}
| j                  |      }|j                  ||||	      }| j	                  |||      \  }}|j
                  \  }}}}| j                  dkD  r1t        j                  || j                   | j                   fd      }n|}t        || j                        }|j                  d| j                  | j                  z  |	      }| j                  |||j                  |j                        }| j                  |||      }|d   }|j                  d| j                  | j                  |	      }t        || j                  ||      }| j                  dkD  r/t        j                  || j                  | j                  fd      }n|}|d   dkD  xs |d   dkD  }|r|d d d |d |d d f   j!                         }|j                  |||z  |	      }|
| j#                  |      z   }| j%                  |      }| j'                  |      }|| j)                  |      z   }|r	||d	   f}|S |f}|S )
Nr   )r   r,   )shiftsdimsr/   r  )r   r   r.   r   )r@  r   r4  r1   rQ  r   r1  rA   rollr9   r4   rL  r  r@   r5  r;   r3   r6  r7  r8  r   )rj   r"   rR  r   rS  r5   r6   r$   r   r   shortcutrP  
height_pad	width_padshifted_hidden_stateshidden_states_windowsrK  attention_outputsr  attention_windowsshifted_windows
was_paddedlayer_outputlayer_outputss                           r(   r   zClapAudioLayer.forward.  s     **+;<("/"4"4"6
Ax --m<%**:vuhO %)NN=&%$P!z&3&9&9#:y!??Q$)JJ}tFVY]YhYhXhEipv$w!$1! !11FHXHX Y 5 : :2t?O?ORVRbRb?bdl m&&	)<)<EZEaEa ' 
	 !NN+@)_pNq,Q/,11"d6F6FHXHXZbc():D<L<LjZcd ??Q %

?DOOUYUdUdCelr s /]Q&;*Q-!*;
 1!WfWfufa2G H S S U-22:v~xX 4>>2C#DD++M:((6$t{{<'@@@Q'8';< YeWfr*   )r  r   FF)rN   rO   rP   ru   r@  rL  rQ  rA   r   rT   rx   r   r   r   r   s   @r(   r,  r,    sz    32) */(->||>  S/>  $;	>
 +> 
u||U\\)	*>r*   r,  c                        e Zd Z fdZ	 	 d	dej
                  deeef   dedz  dedz  deej
                     f
dZ	 xZ
S )
ClapAudioStagec                 H   t         	|           || _        || _        t	        j
                  t        |      D cg c]-  }t        ||||||   |dz  dk(  rdn|j                  dz        / c}      | _	        | ||      | _
        d| _        y d | _
        d| _        y c c}w )Nr,   r   )rm   r   r2  r   r9  r1  r   F)rt   ru   rm   r   r   
ModuleListranger,  r4   blocks
downsamplepointing)
rj   rm   r   r2  depthr   r6  rj  ir   s
            r(   ru   zClapAudioStage.__init__q  s    mm u
  !%5'#,Q<%&UaZqf6H6HA6M

 !(S1DO  #DO'
s   2Br"   rR  r   NrS  r=   c                    |\  }}t        | j                        D ]  \  }} |||||      }	|	d   } |}
| j                  )|dz   dz  |dz   dz  }}||||f}| j                  |
|      }n||||f}||
|f}|r|	dd  z  }|S )Nr   r   r,   )	enumerateri  rj  )rj   r"   rR  r   rS  r5   r6   rm  layer_modulerb  !hidden_states_before_downsamplingheight_downsampledwidth_downsampledoutput_dimensionsstage_outputss                  r(   r   zClapAudioStage.forward  s     )(5 	-OA|(8HJ[]mnM)!,M	-
 -:)??&5;aZA4EPQ	VWGW 1!'0BDU V OO,MO_`M!' >&(IK\]]12..Mr*   rc  )rN   rO   rP   ru   rA   r   rT   rx   r   r   r   r   s   @r(   re  re  p  sb    < */(-||  S/  $;	
 + 
u||	r*   re  c                        e Zd ZdZdeddf fdZdej                  dededej                  fd	Zdej                  d
e	eef   dej                  fdZ
 xZS )ClapAudioPatchMergingzd
    Patch Merging Layer.

    Args:
        dim (`int`):
            Number of input channels.
    r   r=   Nc                     t         |           t        j                  d|z  d|z  d      | _        t        j
                  d|z        | _        y )Nr-   r,   Fr   )rt   ru   r   r   	reductionr   r   )rj   r   r   s     r(   ru   zClapAudioPatchMerging.__init__  s>    1s7AG%@LLS)	r*   input_featurer5   r6   c           
      ~    |dz  dk(  s|dz  dk(  r,t         j                  j                  |ddd|dz  d|dz  f      }|S )zPPad input feature map to be divisible by 2 in both spatial dimensions if needed.r,   r   r   )r   rD   r   )rj   rz  r5   r6   s       r(   rQ  zClapAudioPatchMerging.maybe_pad  sL    QJ!OaMM--maAuqyRSU[^_U_=`aMr*   rR  c                    |\  }}|j                   \  }}}|j                  ||||      }| j                  |||      }t        j                  t        d      D 	cg c]%  }t        d      D ]  }	|d d |	d d|d dd d f    ' c}	}d      }|j                  |dd|z        }| j                  |      }| j                  |      }|S c c}	}w )Nr,   r/   r   r-   )r   r1   rQ  rA   catrh  r   ry  )
rj   rz  rR  r5   r6   r$   r   r7   colrows
             r(   r   zClapAudioPatchMerging.forward  s    ((5(;(;%
C%**:vulS}feD		<A!HYSPUVWPXY]1cf1fcf1fa/0Y0Y_a
 &**:r1|;KL		-0}5 Zs   *C
)rN   rO   rP   rQ   rx   ru   rA   r   rQ  rT   r   r   r   s   @r(   rw  rw    su    *C *D *
u|| S  QVQ]Q] U\\ U3PS8_ Y^YeYe r*   rw  c                        e Zd Z fdZd Ze	 	 	 	 	 	 ddej                  dz  dedz  dedz  dedz  dedz  d	edz  d
e	e
z  fd       Z xZS )ClapAudioEncoderc                    t         |           t        |j                        | _        || _        t        |      | _        |j                  | _        | j                  j                  | _	        |j                  | _
        |j                  |j                  z  | _        t        |j                  d| j                  dz
  z  z        | _        t!        j"                  d|j$                  t'        |j                        d      D cg c]  }|j)                          }}| j                  j*                  }t-        | j                        D cg c]  }|d   d|z  z  |d   d|z  z  f c}| _        t1        j2                  t-        | j                        D cg c]  }t5        |t        |j                  d|z  z        | j.                  |   |j                  |   |j6                  |   |t'        |j                  d |       t'        |j                  d |dz           || j                  dz
  k  rt8        nd        c}      | _        d| _        t1        j>                  |j                        | _         t1        jB                  | j                        | _"        |j                  | _        t1        jF                  d      | _$        y c c}w c c}w c c}w )Nr,   r   r   cpur?   )rm   r   r2  rl  r   r6  rj  F)%rt   ru   rC   depths
num_layersrm   r   patch_embedr   r   r   num_mel_bins
freq_ratiorx   rv   num_featuresrA   linspacer9  r   itemr   rh  input_resolutionsr   rg  re  r   rw  layersgradient_checkpointingr{   
batch_normr   r   AdaptiveAvgPool1davgpool)rj   rm   xr9  r   rm  i_layerr   s          r(   ru   zClapAudioEncoder.__init__  sW   fmm,.v6#11 ,,99)) **f.A.AA ? ?!Z[H[B\ \],1NN1f>S>SUXY_YfYfUgpu,vwq!&&(ww$$..	\abfbqbq\r!sWX9Q<AqD#99Q<AqD;Q"R!smm  %T__5  !F;;ajHI%)%;%;G%D --0$88A,Sx1H-ICPVP]P]^k`gjk`kPlLmn9@4??UVCV9V4]a
 ',#..)<)<=LL!2!23	mm++A.3 x "ts   J<KB#Kc                    |j                   \  }}}}t        | j                  | j                  z        }| j                  | j                  z  }||kD  s||kD  rt	        d      ||k  r%t
        j                  j                  |||fdd      }||k  r%t
        j                  j                  |||fdd      }|j                   \  }}}	}
|j                  ||| j                  z  |	| j                  z  |
      }|j                  dddd      j                         }|j                  |||
| j                  z  |	| j                  z        }|S )	z
        The input is 4 normalized log mel spectrograms. It is reshape to the common shape of images. Each channel
        should represent 1 of the 4 crops of the spectrogram. For more details, refer to the [`ClapFeatureExtractor`].
        z@the wav size should be less than or equal to the swin input sizebicubicT)modealign_cornersr   r   r   r,   )r   rx   r   r  r   r   rD   r)   r!   r2   r3   )rj   normalized_input_featuresr   r%   freq_length
spec_widthspec_heightbatchr   timefreqs              r(   reshape_mel2imgz ClapAudioEncoder.reshape_mel2img  s`   
 *C)H)H&1k;$//9:
nn7#{['@_`` #(*(A(A)J+D9dh )B )% $(*(A(A)K+EIei )B )% '@&E&E#xt %>$E$E8doo-tt/F%
! %>$E$EaAq$Q$\$\$^!$=$E$E8TDOO3TT__5L%
! )(r*   N	is_longerr   output_hidden_states(output_hidden_states_before_downsamplingrS  return_dictr=   c                 J   |xs | j                   j                  }|xs | j                   j                  }|j                  dd      }| j	                  |      }|j                  dd      }d }	| j
                  r6|j                  |j                        }
t        j                  |
dk(        d   }	| j                  |      }|j                  d   }| j                  ||	      }|rdnd }|rdnd }|rdnd }| j                  d   }|rE|j                  \  }}} |j                  |g|| }|j                  dddd      }||fz  }||fz  }t!        | j"                        D ]  \  }}| j                  |   } |||||      }|d   }|d   }|d   }|d   |d   f}|rP|rN|j                  \  }}} |j                  |g|d   |d   f| }|j                  dddd      }||fz  }||fz  }nI|rG|sE|j                  \  }}} |j                  |g|| }|j                  dddd      }||fz  }||fz  }|s||dd  z  } | j%                  |      }|j                  \  }}}|dt'        | j(                        dz
  z  z  | j*                  d   z  }|dt'        | j(                        dz
  z  z  | j*                  d   z  }|j                  ddd      j-                         j/                  ||||      }|j                  \  }}}}|| j0                  z  } |j/                  |||| z  | |      }|j                  ddddd      j-                         j/                  ||| d      }| j3                  t        j4                  |d            }!t        j4                  |!d      }!t7        ||!||	      S )
Nr   r   r   r,   rU   r   r/   r-   )rL   pooler_outputr"   rM   )rm   r  r   r   r  r   rC  r@   rA   wherer  r   r  r  r1   r2   ro  r  r   rC   r  r   r3   r!   r  r  r   r   )"rj   input_featuresr  r   r  r  rS  r  r  is_longer_list_idxis_longer_listr"   
frames_numall_hidden_statesall_reshaped_hidden_statesall_self_attentionsrR  r$   r   hidden_sizereshaped_hidden_staterm  rp  rb  rq  rt  rL   
n_channels
freq_shapetemporal_shapen_frequenciesn_temp
c_freq_binlatent_outputs"                                     r(   r   zClapAudioEncoder.forward  sc     4Wt{{7W7W-N1N1N'11!Q7$(OON$C!$=$G$G1$M!!&\\.*?*?@N!&^q-@!A!!D,,-FG"((+
((8JK"6BD+?RT"$5b411!4)6)<)<&J;$6M$6$6z$bDT$bVa$b!$9$A$A!Q1$M!-!11&+@*BB&(5 	9OA|#55a8(8HJ[]mnM)!,M0=a0@- -a 0 1" 57H7LM#(P-N-T-T*
A{ )O(I(N(N)"3A"68I!8L!M)OZ)% )>(E(EaAq(Q%!&G%II!*/D.FF*%.V-:-@-@*
A{(:(:(::(fHX(fZe(f%(=(E(EaAq(Q%!m%55!*/D.FF* #}QR'88#?	9B !IIm4$5$;$;!
AzA#dkk*:Q*>$?@DDUDUVWDXX
#c$++.>.B(CDHYHYZ[H\\ %%aA.99;CCJPZ\fhvw 	 9J8O8O5
Jv"doo5
-55
MZ$?V
 %%aAq!4??AII*V`blnpq 	 U]]3Da%HImQ7)/'4*	
 	
r*   )NFFFFT)rN   rO   rP   ru   r  r   rA   rR   r   rT   rW   r   r   r   s   @r(   r  r    s    &/P")H  /3).,1@E(-#'h
 $$t+h
  $;	h

 #Tkh
 37+h
 +h
 D[h
 
%	%h
 h
r*   r  c                   0     e Zd Zdeez  f fdZd Z xZS )ClapProjectionLayerrm   c                     t         |           || _        |j                  }|j                  }t        j                  ||      | _        t        |j                     | _
        t        j                  ||      | _        y rb   )rt   ru   rm   r  projection_dimr   r   linear1r	   projection_hidden_act
activationlinear2)rj   rm   r  r  r   s       r(   ru   zClapProjectionLayer.__init__  sa    ((..yyn= !=!=>yy@r*   c                 l    | j                  |      }| j                  |      }| j                  |      }|S rb   )r  r  r  r  s     r(   r   zClapProjectionLayer.forward  s2    ]36]3r*   )rN   rO   rP   r   r   ru   r   r   r   s   @r(   r  r    s    A? Ar*   r  c                        e Zd ZdZ fdZ	 	 	 	 	 ddej                  dz  dej                  dz  dej                  dz  dej                  dz  ded	ej                  fd
Z
ed        Zedd       Z xZS )ClapTextEmbeddingszGConstruct the embeddings from word, position and token_type embeddings.c                 T   t         |           t        j                  |j                  |j
                  |j                        | _        t        j                  |j                  |j
                        | _	        t        j                  |j
                  |j                        | _
        t        j                  |j                        | _        | j                  dt!        j"                  |j$                        j'                  d      d       | j                  dt!        j(                  | j*                  j-                         t         j.                        d       |j                  | _        t        j                  |j$                  |j
                  | j0                        | _        y )	N)padding_idxr.  position_idsr   r/   T)
persistenttoken_type_ids)r  )rt   ru   r   	Embedding
vocab_sizer  pad_token_idword_embeddingstype_vocab_sizetoken_type_embeddingsr   r3  r   r  r   r   rA   rB   max_position_embeddingsexpandr   r  r   rB  r  position_embeddingsrj   rm   r   s     r(   ru   zClapTextEmbeddings.__init__  s4   !||F,=,=v?Q?Q_e_r_rs%'\\&2H2H&J\J\%]"f&8&8f>S>STzz&"<"<=ELL)G)GHOOPWXei 	 	
 	ekk$*;*;*@*@*B%**Ubf 	 	
 "..#%<<**F,>,>DL\L\$
 r*   N	input_idsr  r  inputs_embedspast_key_values_lengthr=   c                    |<|| j                  || j                  |      }n| j                  || j                        }||j                         }n|j                         d d }|\  }}|t	        | d      rm| j
                  j                  |j                        j                  |j                  d   d      }	t        j                  |	d|      }	|	j                  ||      }n:t        j                  |t        j                  | j                  j                        }|| j                  |      }| j!                  |      }
||
z   }| j#                  |      }||z   }| j%                  |      }| j'                  |      }|S )Nr/   r  r   r   )r   indexr  )"create_position_ids_from_input_idsr  &create_position_ids_from_inputs_embedsr   hasattrr  rC  r@   r  r   rA   gatherr   rB  r  r  r  r  r   r   )rj   r  r  r  r  r  input_shaper$   
seq_lengthbuffered_token_type_idsr  
embeddingsr  s                r(   r   zClapTextEmbeddings.forward  s    $#FFt//1G   $JJ=Z^ZjZjk #..*K',,.s3K!,
J
 !t-.*.*=*=*@*@ATAT*U*\*\]i]o]opq]rtv*w'*/,,7NTU]i*j'!8!?!?
J!W!&[

SWSdSdSkSk!l  00;M $ : :> J"%::
"66|D"55
^^J/
\\*-
r*   c                     | j                         dd }|d   }t        j                  |dz   ||z   dz   t        j                  | j                        }|j                  d      j                  |      S )z
        We are provided embeddings directly. We cannot infer which are padded so just generate sequential position ids.

        Args:
            inputs_embeds: torch.Tensor

        Returns: torch.Tensor
        Nr/   r   r  r   )r   rA   rB   rB  r@   r   r  )r  r  r  sequence_lengthr  s        r(   r  z9ClapTextEmbeddings.create_position_ids_from_inputs_embeds  sp     $((*3B/%a.||!O_{:Q>ejjYfYmYm
 %%a(//<<r*   c                     | j                  |      j                         }t        j                  |d      j	                  |      |z   |z  }|j                         |z   S )a  
        Replace non-padding symbols with their position numbers. Position numbers begin at padding_idx+1. Padding symbols
        are ignored. This is modified from fairseq's `utils.make_positions`.

        Args:
            x: torch.Tensor x:

        Returns: torch.Tensor
        r   r   )nerx   rA   cumsumtype_asrB  )r  r  r  maskincremental_indicess        r(   r  z5ClapTextEmbeddings.create_position_ids_from_input_ids  sW     ||K(,,.$||Da8@@FI__cgg"'')K77r*   )NNNNr   )r   )rN   rO   rP   rQ   ru   rA   
LongTensorrR   rx   r   r   staticmethodr  r  r   r   s   @r(   r  r    s    Q
, .2260426&'.##d*. ((4/. &&-	.
 ((4/. !$. 
.` = =" 8 8r*   r  moduler   r   r   r   scalingr   c                    t        j                  ||j                  dd            |z  }|||z   }t        j                  j                  |dt         j                        j                  |j                        }t        j                  j                  ||| j                        }t        j                  ||      }	|	j                  dd      j                         }	|	|fS )Nr,   r   r/   )r   r  )pr   r   )rA   r   r   r   rD   r   float32rC  r  r   r   r3   )
r  r   r   r   r   r  r   kwargsattn_weightsattn_outputs
             r(   eager_attention_forwardr    s     <<s}}Q':;gEL!#n4==((2U]](SVVW\WbWbcL==((6??([L,,|U3K''1-88:K$$r*   c                        e Zd Z fdZ	 ddej
                  dej                  dz  dee   de	ej
                  ej
                  dz  f   fdZ
 xZS )	ClapTextSelfAttentionc                 $   t         |           |j                  |j                  z  dk7  r2t	        |d      s&t        d|j                   d|j                   d      || _        |j                  | _        t        |j                  |j                  z        | _        | j                  | j                  z  | _	        t        j                  |j                  | j                        | _        t        j                  |j                  | j                        | _        t        j                  |j                  | j                        | _        t        j                  |j                         | _        |j                   | _        | j                  dz  | _        y )Nr   embedding_sizer   r   r         )rt   ru   r  r   r  r   rm   rx   r   r   r   r   r   r   r   r   r   r   attention_dropoutr  r  s     r(   ru   zClapTextSelfAttention.__init__  sC    : ::a?PVXhHi#F$6$6#7 8 445Q8 
 #)#=#= #&v'9'9F<V<V'V#W !558P8PPYYv1143E3EF
99V//1C1CDYYv1143E3EF
zz&"E"EF!'!D!D//5r*   Nr"   r   r  r=   c                 x   |j                   d d }g |d| j                  }| j                  |      j                  |      j	                  dd      }| j                  |      j                  |      j	                  dd      }| j                  |      j                  |      j	                  dd      }t        j                  | j                  j                  t              }	 |	| ||||f| j                  sdn| j                  | j                  d|\  }
} |
j                  g |d j!                         }
|
|fS )Nr/   r   r,   r  )r   r  )r   r   r   r1   r   r   r   r   get_interfacerm   _attn_implementationr  r   r  r  r!   r3   )rj   r"   r   r  r  r   query_states
key_statesvalue_statesattention_interfacer  r  s               r(   r   zClapTextSelfAttention.forward4  s>    $))#2.CCbC$*B*BCzz-055lCMMaQRSXXm,11,?II!QO
zz-055lCMMaQRS(?(M(MKK,,.E)
 %8	%
  $}}C$2H2HLL	%
 	%
!\ *k));;;;FFHL((r*   rb   )rN   rO   rP   ru   rA   r   rR   r   r   rT   r   r   r   s   @r(   r  r    sd    60 48)||) ))D0) +,	)
 
u||U\\D00	1)r*   r  c                   n     e Zd Z fdZdej
                  dej
                  dej
                  fdZ xZS )ClapTextSelfOutputc                 (   t         |           t        j                  |j                  |j                        | _        t        j                  |j                  |j                        | _        t        j                  |j                        | _
        y Nr.  )rt   ru   r   r   r  r   r   r3  r   r  r   r  s     r(   ru   zClapTextSelfOutput.__init__V  s`    YYv1163E3EF
f&8&8f>S>STzz&"<"<=r*   r"   r   r=   c                 r    | j                  |      }| j                  |      }| j                  ||z         }|S rb   r   r   r   r   s      r(   r   zClapTextSelfOutput.forward\  7    

=1]3}|'CDr*   r   r   s   @r(   r   r   U  1    >U\\  RWR^R^ r*   r   c            	            e Zd Z fdZ	 ddej
                  dej                  dz  dee   dej
                  fdZ	 xZ
S )	ClapTextAttentionc                 b    t         |           t        |      | _        t	        |      | _        y rb   )rt   ru   r  rj   r   r   r  s     r(   ru   zClapTextAttention.__init__e  s&    )&1	(0r*   Nr"   r   r  r=   c                 ^    |} | j                   |fd|i|\  }}| j                  ||      }|S Nr   r  )rj   r"   r   r  r   r   s         r(   r   zClapTextAttention.forwardj  sK     !$499
)
 
q
 M8<r*   rb   )rN   rO   rP   ru   rA   r   rR   r   r   r   r   r   s   @r(   r  r  d  sQ    1 48|| ))D0 +,	
 
r*   r  c                   V     e Zd Z fdZdej
                  dej
                  fdZ xZS )ClapTextIntermediatec                    t         |           t        j                  |j                  |j
                        | _        t        |j                  t              rt        |j                     | _        y |j                  | _        y rb   )rt   ru   r   r   r  intermediate_sizer   rc   r  r  r	   r  r  s     r(   ru   zClapTextIntermediate.__init__|  s]    YYv1163K3KL
f''-'-f.?.?'@D$'-'8'8D$r*   r"   r=   c                 J    | j                  |      }| j                  |      }|S rb   r  r  s     r(   r   zClapTextIntermediate.forward  r  r*   r   r   s   @r(   r  r  {  r  r*   r  c                   n     e Zd Z fdZdej
                  dej
                  dej
                  fdZ xZS )ClapTextOutputc                 (   t         |           t        j                  |j                  |j
                        | _        t        j                  |j
                  |j                        | _        t        j                  |j                        | _        y r  )rt   ru   r   r   r  r  r   r   r3  r   r  r   r  s     r(   ru   zClapTextOutput.__init__  s`    YYv779K9KL
f&8&8f>S>STzz&"<"<=r*   r"   r   r=   c                 r    | j                  |      }| j                  |      }| j                  ||z         }|S rb   r  r   s      r(   r   zClapTextOutput.forward  r  r*   r   r   s   @r(   r  r    r  r*   r  c            	            e Zd Z fdZ	 d	dej
                  dej                  dz  dee   dej
                  fdZ	d Z
 xZS )
ClapTextLayerc                     t         |           |j                  | _        d| _        t	        |      | _        t        |      | _        t        |      | _	        y )Nr   )
rt   ru   r0  seq_len_dimr  r5  r  r8  r  r   r  s     r(   ru   zClapTextLayer.__init__  sI    '-'E'E$*6208$V,r*   Nr"   r   r  r=   c                      | j                   |fd|i|}t        | j                  | j                  | j                  |      }|S r  )r5  r   feed_forward_chunkr0  r  )rj   r"   r   r  s       r(   r   zClapTextLayer.forward  sY     '
)
 
 2##T%A%A4CSCSUb
 r*   c                 L    | j                  |      }| j                  ||      }|S rb   )r8  r   )rj   r  intermediate_outputra  s       r(   r  z ClapTextLayer.feed_forward_chunk  s,    "//0@A{{#68HIr*   rb   )rN   rO   rP   ru   rA   r   rR   r   r   r   r  r   r   s   @r(   r  r    sV    - 48|| ))D0 +,	
 
$r*   r  c            	       n     e Zd Z fdZ	 ddej
                  dej                  dz  dee   de	fdZ
 xZS )	ClapTextEncoderc                     t         |           || _        t        j                  t        |j                        D cg c]  }t        |       c}      | _        d| _	        y c c}w r   )
rt   ru   rm   r   rg  rh  num_hidden_layersr  layerr  )rj   rm   rm  r   s      r(   ru   zClapTextEncoder.__init__  sN    ]]5IaIaCb#caM&$9#cd
&+# $ds   A#Nr"   r   r  r=   c                 P    | j                   D ]  } |||fi |} t        |      S )N)rL   )r!  r   )rj   r"   r   r  rp  s        r(   r   zClapTextEncoder.forward  sC     !JJ 	L( M	 +
 	
r*   rb   )rN   rO   rP   ru   rA   r   rR   r   r   r   r   r   r   s   @r(   r  r    sM    , 48
||
 ))D0
 +,	

 

r*   r  c                   V     e Zd Z fdZdej
                  dej
                  fdZ xZS )ClapTextPoolerc                     t         |           t        j                  |j                  |j                        | _        t        j                         | _        y rb   )rt   ru   r   r   r  r   Tanhr  r  s     r(   ru   zClapTextPooler.__init__  s9    YYv1163E3EF
'')r*   r"   r=   c                 \    |d d df   }| j                  |      }| j                  |      }|S r;  )r   r  )rj   r"   first_token_tensorpooled_outputs       r(   r   zClapTextPooler.forward  s6     +1a40

#566r*   r   r   s   @r(   r$  r$    s#    $
U\\ ell r*   r$  c                   x     e Zd ZU eed<   dZdZdZ ej                         de
j                  f fd       Z xZS )ClapPreTrainedModelrm   clap)audiotextFr  c                    t         |   |       | j                  j                  }t	        |t
              rt        j                  |j                  j                  d|dz         t        j                  |j                  j                  d|dz         t        j                  |j                  t        j                  |j                  j                  d         j!                  d             t        j"                  |j$                         y	t	        |t&              rt        j(                  |j*                  t-        j.                  | j                  j0                               t        j(                  |j2                  t-        j.                  | j                  j0                               y	t	        |t4        j6                        r&t        j                  |j                  d|dz         y	t	        |t4        j8                  t4        j:                  f      r| j                  j<                  dz  d| j                  j>                  z  dz  z  |z  }t        j                  |j                  |       |j@                   t        j"                  |j@                         y	y	t	        |tB              rNt        j"                  |jD                         t        j                  |jF                  |jI                                y	y	)
zInitialize the weightsr  g{Gz?)meanstdr/   r  r  r,   )r1  N)%rt   _init_weightsrm   initializer_factorrc   r  initnormal_r  weightr  copy_r  rA   rB   r   r  zeros_r  	ClapModel	constant_logit_scale_ar   loglogit_scale_init_valuelogit_scale_tr   r  rz   r   r  r   r   r   r   r   r   )rj   r  factorin_proj_stdr   s       r(   r2  z!ClapPreTrainedModel._init_weights  s    	f%//f01LL33::&SW-XLL55<<3FUYMZJJv**ELL9L9L9R9RSU9V,W,^,^_f,ghKK--.	*NN6//$++:\:\1]^NN6//$++:\:\1]^-LLSftmDBII 67;;22D8a$++B_B_>_dh=hilrrKLLK8{{&FKK( ' 67KK;;<JJv55v7\7\7^_ 8r*   )rN   rO   rP   r   rS   base_model_prefixinput_modalitiessupports_gradient_checkpointingrA   no_gradr   Moduler2  r   r   s   @r(   r+  r+    sC    (&+#U]]_`BII ` `r*   r+  c                        e Zd ZU eed<   dZdZdef fdZdej                  fdZ
e	 	 ddej                  dz  dej                  dz  d	ee   deez  fd
       Z xZS )ClapAudioModelrm   r  r-  c                 d    t         |   |       t        |      | _        | j	                          y rb   )rt   ru   r  audio_encoder	post_initr  s     r(   ru   zClapAudioModel.__init__  s'     -f5r*   r=   c                 B    | j                   j                  j                  S rb   )rI  r  r   ri   s    r(   get_input_embeddingsz#ClapAudioModel.get_input_embeddings  s    !!--222r*   Nr  r  c                 ,     | j                   d||d|S )ad  
        is_longer (`torch.FloatTensor`, of shape `(batch_size, 1)`, *optional*):
            Whether the audio clip is longer than `max_length`. If `True`, a feature fusion will be enabled to enhance
            the features.

        Examples:

        ```python
        >>> from datasets import load_dataset
        >>> from transformers import AutoProcessor, ClapAudioModel

        >>> dataset = load_dataset("hf-internal-testing/ashraq-esc50-1-dog-example")
        >>> audio_sample = dataset["train"]["audio"][0]["array"]

        >>> model = ClapAudioModel.from_pretrained("laion/clap-htsat-fused")
        >>> processor = AutoProcessor.from_pretrained("laion/clap-htsat-fused")

        >>> inputs = processor(audio=audio_sample, return_tensors="pt")

        >>> outputs = model(**inputs)
        >>> last_hidden_state = outputs.last_hidden_state
        ```r  r  rU   )rI  )rj   r  r  r  s       r(   r   zClapAudioModel.forward  s.    : "t!! 
)
 
 	
r*   NN)rN   rO   rP   r   rS   main_input_namerB  ru   r   rE  rL  r   rA   rR   
BoolTensorr   r   rT   r   r   r   r   s   @r(   rG  rG    s    &O 3bii 3  48-1 
))D0 
 ##d* 
 +,	 

 
+	+ 
  
r*   rG  a0  
    The model can behave as an encoder (with only self-attention) as well as a decoder, in which case a layer of
    cross-attention is added between the self-attention layers, following the architecture described in *Attention is
    all you need*_ by Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N. Gomez, Lukasz
    Kaiser and Illia Polosukhin.

    To behave as an decoder the model needs to be initialized with the `is_decoder` argument of the configuration set
    to `True`. To be used in a Seq2Seq model, the model needs to initialized with both `is_decoder` argument and
    `add_cross_attention` set to `True`; an `encoder_hidden_states` is then expected as an input to the forward pass.

    .. _*Attention is all you need*: https://huggingface.co/papers/1706.03762
    c                       e Zd ZU eed<   dZeedZd fd	Z	d Z
d Zeee	 	 	 	 	 ddej                   dz  d	ej                   dz  d
ej                   dz  dej                   dz  dej                   dz  dee   defd                     Z xZS )ClapTextModelrm   r.  r"   rM   c                     t         |   |       || _        t        |      | _        t        |      | _        |rt        |      nd| _        | j                          y)zv
        add_pooling_layer (bool, *optional*, defaults to `True`):
            Whether to add a pooling layer
        N)
rt   ru   rm   r  r  r  encoderr$  poolerrJ  )rj   rm   add_pooling_layerr   s      r(   ru   zClapTextModel.__init__N  sM    
 	 ,V4&v.0AnV,t 	r*   c                 .    | j                   j                  S rb   r  r  ri   s    r(   rL  z"ClapTextModel.get_input_embeddings^  s    ...r*   c                 &    || j                   _        y rb   r[  rj   r   s     r(   set_input_embeddingsz"ClapTextModel.set_input_embeddingsa  s    */'r*   Nr  r   r  r  r  r  r=   c                    ||t        d      |#| j                  ||       |j                         }n!||j                         d d }nt        d      |\  }}	||j                  n|j                  }
|t	        j
                  ||	f|
      }| j                  ||||      }t        | j                  ||      } | j                  |fd|i|}|d   }| j                  | j                  |      nd }t        ||	      S )
NzDYou cannot specify both input_ids and inputs_embeds at the same timer/   z5You have to specify either input_ids or inputs_embedsr?   )r  r  r  r  )rm   r  r   r   r   )rL   r  )r   %warn_if_padding_and_no_attention_maskr   r@   rA   onesr  r
   rm   rW  rX  r   )rj   r  r   r  r  r  r  r  r$   r  r@   embedding_outputencoder_outputssequence_outputr)  s                  r(   r   zClapTextModel.forwardd  s:     ]%>cdd"66y.Q#..*K&',,.s3KTUU!,
J%.%:!!@T@T!"ZZ*j)A6RN??%)'	 + 
 3;;*)
 '$,,
)
 

 *!,8<8OO4UY)-'
 	
r*   )T)NNNNN)rN   rO   rP   r   rS   rB  r  r  _can_record_outputsru   rL  r^  r   r   r   rA   r   r   r   r   r   r   r   s   @r(   rS  rS  8  s      &+
 /0   *..2.2,0-11
<<$&1
 t+1
 t+	1

 llT)1
 ||d*1
 +,1
 
$1
    1
r*   rS  c                   "    e Zd ZU eed<   def fdZee	 	 ddej                  dej                  dz  dej                  dz  de
e   deez  f
d	              Zee	 	 dd
ej                  dej                  dz  dej                  dz  de
e   deez  f
d              Zee	 	 	 	 	 	 ddej                   dz  d
ej"                  dz  dej$                  dz  dej                  dz  dej                   dz  dedz  de
e   deez  fd              Z xZS )r9  rm   c                 .   t         |   |       t        |j                  t              s"t        dt        |j                         d      t        |j                  t              s"t        dt        |j                         d      |j                  }|j                  }t        j                  t        j                  t        j                  |j                                    | _        t        j                  t        j                  t        j                  |j                                    | _        |j$                  | _        t'        |      | _        t+        |      | _        t/        |      | _        t+        |      | _        | j5                          y )NzKconfig.text_config is expected to be of type ClapTextConfig but is of type .zMconfig.audio_config is expected to be of type ClapAudioConfig but is of type )rt   ru   rc   text_configr   	TypeErrortypeaudio_configr   r   r   rA   r?  r   r<  r=  r;  r>  r  rS  
text_modelr  text_projectionrG  audio_modelaudio_projectionrJ  )rj   rm   ri  rl  r   s       r(   ru   zClapModel.__init__  s=    &,,n=++,-Q0 
 &--?,,-.a1 
 ((**\\%,,txx@]@]7^*_`\\%,,txx@]@]7^*_`$33'42;?),7 3L A 	r*   Nr  r   r  r  r=   c                      | j                   d|||d|}| j                  |j                        }t        j                  |d      |_        |S )a  
        Examples:

        ```python
        >>> import torch
        >>> from transformers import AutoTokenizer, ClapModel

        >>> model = ClapModel.from_pretrained("laion/clap-htsat-unfused")
        >>> tokenizer = AutoTokenizer.from_pretrained("laion/clap-htsat-unfused")

        >>> inputs = tokenizer(["the sound of a cat", "the sound of a dog"], padding=True, return_tensors="pt")
        >>> with torch.inference_mode():
        ...     text_features = model.get_text_features(**inputs)
        ```r  r   r  r/   r   rU   )rm  rn  r  F	normalize)rj   r  r   r  r  text_outputstext_featuress          r(   get_text_featureszClapModel.get_text_features  s^    . 4C4?? 4
)%4
 	4
 ,,\-G-GH%&[[B%G"r*   r  r  c                      | j                   d||d|}| j                  |j                        }t        j                  |d      |_        |S )a  
        is_longer (`torch.FloatTensor`, of shape `(batch_size, 1)`, *optional*):
            Whether the audio clip is longer than `max_length`. If `True`, a feature fusion will be enabled to enhance
            the features.

        Examples:

        ```python
        >>> import torch
        >>> from transformers import AutoFeatureExtractor, ClapModel

        >>> model = ClapModel.from_pretrained("laion/clap-htsat-unfused")
        >>> feature_extractor = AutoFeatureExtractor.from_pretrained("laion/clap-htsat-unfused")
        >>> random_audio = torch.rand((16_000))

        >>> inputs = feature_extractor(random_audio, return_tensors="pt")
        >>> with torch.inference_mode():
        ...     audio_features = model.get_audio_features(**inputs)
        ```rN  r/   r   rU   )ro  rp  r  rs  rt  )rj   r  r  r   r  audio_outputsaudio_featuress          r(   get_audio_featureszClapModel.get_audio_features  sZ    8 5ED4D4D 5
)Y5
BH5
 ..}/J/JK&'kk.b&I#r*   return_lossc           	          | j                   d
||d|} | j                  d
|||d|}	|j                  }
| j                  |
      }
|	j                  }| j	                  |      }|
|
j                  ddd      z  }
||j                  ddd      z  }| j                  j                         }| j                  j                         }t        j                  ||
j                               |z  }t        j                  |
|j                               |z  }d}|r,t        |      }t        |j                               }||z   dz  }t        |||||
|	|	      S )a  
        is_longer (`torch.FloatTensor`, of shape `(batch_size, 1)`, *optional*):
            Whether the audio clip is longer than `max_length`. If `True`, a feature fusion will be enabled to enhance
            the features.
        return_loss (`bool`, *optional*):
            Whether or not to return the contrastive loss.

        Examples:

        ```python
        >>> from datasets import load_dataset
        >>> from transformers import AutoProcessor, ClapModel

        >>> dataset = load_dataset("hf-internal-testing/ashraq-esc50-1-dog-example")
        >>> audio_sample = dataset["train"]["audio"][0]["array"]

        >>> model = ClapModel.from_pretrained("laion/clap-htsat-unfused")
        >>> processor = AutoProcessor.from_pretrained("laion/clap-htsat-unfused")

        >>> input_text = ["Sound of a dog", "Sound of vacuum cleaner"]

        >>> inputs = processor(text=input_text, audio=audio_sample, return_tensors="pt", padding=True)

        >>> outputs = model(**inputs)
        >>> logits_per_audio = outputs.logits_per_audio  # this is the audio-text similarity score
        >>> probs = logits_per_audio.softmax(dim=-1)  # we can take the softmax to get the label probabilities
        ```rN  rr  r,   r/   T)r  r   keepdimNg       @)r[   r\   r]   rK   rX   r^   r_   rU   )ro  rm  r  rp  rn  r   r>  expr;  rA   r   trG   rZ   )rj   r  r  r  r   r  r|  r  ry  ru  rX   rK   logit_scale_textlogit_scale_audior]   r\   r[   caption_loss
audio_losss                      r(   r   zClapModel.forward  s   N )(( 
)
 
 't 
)%
 	
 %22,,\:"00**;7 $l&7&7!T&7&RR!K$4$4qb$$4$OO  --113 ..224,,{LNN4DEHXX <<kmmoFIZZ+O<L)*:*<*<*>?J :-4D-+#%*,
 	
r*   rO  )NNNNNN)rN   rO   rP   r   rS   ru   r   r   rA   r   r   r   rT   r   rw  r{  r  rR   rQ  r   rZ   r   r   r   s   @r(   r9  r9    s   z @  /3,0	<< t+ llT)	
 +, 
+	+  @  *..2	   <<$&  t+	 
 +,  
+	+    D  .237-1.204#'P
##d*P
 ))D0P
 ##d*	P

 t+P
 &&-P
 D[P
 +,P
 
	P
  P
r*   r9  c                        e Zd ZU eed<   dZeedZdef fdZ	de
j                  fdZd Zee	 	 	 dd	ej"                  dz  d
ej"                  dz  dej"                  dz  dee   deez  f
d              Z xZS )ClapTextModelWithProjectionrm   rT  rU  c                     t         |   |       t        |      | _        t	        |      | _        | j                          y rb   )rt   ru   rS  rm  r  rn  rJ  r  s     r(   ru   z$ClapTextModelWithProjection.__init__c  s3     '/26:r*   r=   c                 B    | j                   j                  j                  S rb   rm  r  r  ri   s    r(   rL  z0ClapTextModelWithProjection.get_input_embeddingsj  s    ))999r*   c                 :    || j                   j                  _        y rb   r  r]  s     r(   r^  z0ClapTextModelWithProjection.set_input_embeddingsm  s    5:""2r*   Nr  r   r  r  c                      | j                   d|||d|}|j                  }| j                  |      }t        ||j                  |j
                  |j                        S )a  
        Examples:

        ```python
        >>> from transformers import AutoTokenizer, ClapTextModelWithProjection

        >>> model = ClapTextModelWithProjection.from_pretrained("laion/clap-htsat-unfused")
        >>> tokenizer = AutoTokenizer.from_pretrained("laion/clap-htsat-unfused")

        >>> inputs = tokenizer(["a sound of a cat", "a sound of a dog"], padding=True, return_tensors="pt")

        >>> outputs = model(**inputs)
        >>> text_embeds = outputs.text_embeds
        ```rr  )rK   rL   r"   rM   rU   )rm  r  rn  rJ   rL   r"   rM   )rj   r  r   r  r  ru  r)  rK   s           r(   r   z#ClapTextModelWithProjection.forwardp  su    . 4C4?? 4
)%4
 	4
 %22**=9"#*<<&44#..	
 	
r*   )NNN)rN   rO   rP   r   rS   rB  r  r  re  ru   r   rE  rL  r^  r   r   rA   r   r   r   rT   rJ   r   r   r   s   @r(   r  r  Z  s     &+
~ :bii :;  *..2,0	#
<<$&#
 t+#
 llT)	#

 +,#
 
$	$#
  #
r*   r  c                        e Zd ZU eed<   dZdZdef fdZdej                  fdZ
ee	 	 ddej                  dz  dej                  dz  d	ee   deez  fd
              Z xZS )ClapAudioModelWithProjectionrm   r  r-  c                     t         |   |       t        |      | _        t	        |      | _        | j                          y rb   )rt   ru   rG  ro  r  rp  rJ  r  s     r(   ru   z%ClapAudioModelWithProjection.__init__  s4     )&1 3F ;r*   r=   c                 V    | j                   j                  j                  j                  S rb   )ro  rI  r  r   ri   s    r(   rL  z1ClapAudioModelWithProjection.get_input_embeddings  s     --99>>>r*   Nr  r  c                      | j                   d||d|}| j                  |j                        }t        ||j                  |j
                  |j                        S )au  
        is_longer (`torch.FloatTensor`, of shape `(batch_size, 1)`, *optional*):
            Whether the audio clip is longer than `max_length`. If `True`, a feature fusion will be enabled to enhance
            the features.

        Examples:

        ```python
        >>> from datasets import load_dataset
        >>> from transformers import ClapAudioModelWithProjection, ClapProcessor

        >>> model = ClapAudioModelWithProjection.from_pretrained("laion/clap-htsat-fused")
        >>> processor = ClapProcessor.from_pretrained("laion/clap-htsat-fused")

        >>> dataset = load_dataset("hf-internal-testing/ashraq-esc50-1-dog-example")
        >>> audio_sample = dataset["train"]["audio"][0]["array"]

        >>> inputs = processor(audio=audio_sample, return_tensors="pt")
        >>> outputs = model(**inputs)
        >>> audio_embeds = outputs.audio_embeds
        ```rN  )rX   rL   rM   r"   rU   )ro  rp  r  rW   rL   rM   r"   )rj   r  r  r  ry  rX   s         r(   r   z$ClapAudioModelWithProjection.forward  so    : 5ED4D4D 5
)5
 5
 ,,]-H-HI#%+==$//'55	
 	
r*   rO  )rN   rO   rP   r   rS   rP  rB  ru   r   rE  rL  r   r   rA   rR   rQ  r   r   rT   rW   r   r   r   s   @r(   r  r    s    &O ?bii ?  48-1(
))D0(
 ##d*(
 +,	(

 
%	%(
  (
r*   r  )r9  r+  rS  r  rG  r  r)  )[rQ   r   r   collections.abcr   dataclassesr   typingr   rA   torch.nn.functionalr   rD   rs   r   r4  activationsr	   masking_utilsr
   modeling_layersr   modeling_outputsr   r   modeling_utilsr   r   processing_utilsr   pytorch_utilsr   utilsr   r   r   r   r   r   utils.genericr   utils.output_capturingr   configuration_clapr   r   r   
get_loggerrN   loggerr)   r9   r;   r   rG   rJ   rW   rZ   rE  rl   r   r   r   r  r  r  r  r,  re  rw  r  r  r  r*  r  r  r   r  r  r  r  r  r$  r+  rG  rS  r9  r  r  __all__rU   r*   r(   <module>r     s      $ !      & ! 6 9 G & 6 j j 7 5 K K 
		H	%"**7U\\ 7ell 7
 
 	<+ 	< 	< 
 	<; 	< 	< 
_ _  _B%		 %P_")) _FZ'RYY Z'|
")) 
 &BII  	bii 	%299 %2tRYY tp4/ 4p%BII %Pv
ryy v
r")) &g8 g8d %II%<<% 
% <<	%
 LL4'% % %.3)BII 3)n 		 .299  RYY . D
bii 
4RYY  `/ ` `@/
( /
d R
' R
R
j {
# {
 {
| :
"5 :
 :
z 9
#6 9
 9
xr*   