
    hI                     f   d dl mZ d dlmZmZmZ d dl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 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m Z  ddl!m"Z" ddl#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/ ddl0m1Z1  e(jd                  e3      Z4e e&d       G d de$                    Z5 ed       G d dejl                               Z7 G d dejl                        Z8 G d  d!ejl                        Z9d" Z:dGd#Z;d$ejx                  d%e=d&ejx                  fd'Z>	 dHd(ejl                  d)ejx                  d*ejx                  d+ejx                  d,eejx                     d-e?d.e?d/e"e%   fd0Z@ G d1 d2ejl                        ZA G d3 d4e      ZB e&d5      e& G d6 d7e                     ZCe& G d8 d9eC             ZD G d: d;ejl                        ZE e&d<       G d= d>eCe             ZF G d? d@ejl                        ZGe& G dA dBeC             ZH e&dC       G dD dEeCe1             ZIg dFZJy)I    )	dataclass)CallableOptionalUnionN)check_model_inputs   )ACT2FN)CacheDynamicCache)GenerationMixin)use_kernel_forward_from_hub)create_causal_mask)GradientCheckpointingLayer)BaseModelOutputWithPastCausalLMOutputWithPast)ROPE_INIT_FUNCTIONSdynamic_rope_update)ALL_ATTENTION_FUNCTIONSPreTrainedModel)Unpack)ModelOutputTransformersKwargsauto_docstringcan_return_tuplelogging)deprecate_kwarg   )	AutoModel   )	CsmConfigCsmDepthDecoderConfig)CsmGenerationMixinz:
    Base class for the model autoregressive outputs.
    )custom_introc                      e Zd ZU dZdZeej                     ed<   dZ	ej                  ed<   dZ
eeeej                           ed<   dZeeej                  df      ed<   dZeeej                  df      ed<   dZeej                     ed	<   dZej                  ed
<   dZeeeej                           ed<   dZeeej                  df      ed<   dZeeej                  df      ed<   dZeej                     ed<   y)CsmOutputWithPasta	
  
    loss (`torch.FloatTensor` of shape `(1,)`, *optional*, returned when `labels` is provided):
        Language modeling loss (for next-token prediction).
    logits (`torch.FloatTensor` of shape `(batch_size, sequence_length, config.vocab_size)`):
        Prediction scores of the language modeling head (scores for each vocabulary token before SoftMax).
    past_key_values (`Cache`, *optional*, returned when `use_cache=True` is passed or when `config.use_cache=True`):
        Tuple of `tuple(torch.FloatTensor)` of length `config.n_layers`, with each tuple having 2 tensors of shape
        `(batch_size, num_heads, sequence_length, embed_size_per_head)`)

        Contains pre-computed hidden-states (key and values in the self-attention blocks) that can be used (see
        `past_key_values` input) to speed up sequential decoding.
    depth_decoder_loss (`torch.FloatTensor` of shape `(1,)`, *optional*, returned when `labels` is provided):
        Language modeling loss (for next-token prediction) of the depth decoder model.
    depth_decoder_logits (`torch.FloatTensor` of shape `(batch_size, sequence_length, config.vocab_size)`):
        Prediction scores of the depth decoder (scores for each vocabulary token before SoftMax).
    depth_decoder_past_key_values (`tuple(tuple(torch.FloatTensor))`, *optional*, returned when `use_cache=True` is passed or when `config.use_cache=True`):
        Tuple of `tuple(torch.FloatTensor)` of length `config.n_layers`, with each tuple having 2 tensors of shape
        `(batch_size, num_heads, sequence_length, embed_size_per_head)`)
    depth_decoder_hidden_states (`tuple(torch.FloatTensor)`, *optional*, returned when `output_hidden_states=True` is passed or when `config.output_hidden_states=True`):
        Tuple of `torch.FloatTensor` (one for the output of the embeddings, if the model has an embedding layer, +
        one for the output of each layer) of shape `(batch_size, sequence_length, hidden_size)`.

        Hidden-states of the model at the output of each layer plus the optional initial embedding outputs.
    depth_decoder_attentions (`tuple(torch.FloatTensor)`, *optional*, returned when `output_attentions=True` is passed or when `config.output_attentions=True`):
        Tuple of `torch.FloatTensor` (one for each layer) of shape `(batch_size, num_heads, sequence_length,
        sequence_length)`.
    backbone_loss (`torch.FloatTensor` of shape `(1,)`, *optional*, returned when `labels` is provided):
        Language modeling loss (for next-token prediction) of the backbone model.
    Nlosslogitspast_key_values.hidden_states
attentionsdepth_decoder_lossdepth_decoder_logitsdepth_decoder_past_key_valuesdepth_decoder_hidden_statesdepth_decoder_attentionsbackbone_loss)__name__
__module____qualname____doc__r&   r   torchFloatTensor__annotations__r'   r(   tupler)   r*   r+   r,   r-   r.   r/   r0        b/var/www/html/eduruby.in/venv/lib/python3.12/site-packages/transformers/models/csm/modeling_csm.pyr%   r%   2   s'   < )-D(5$$
%, $FE$AEOXeE%*;*;$<=>E=AM8E%"3"3S"89:A:>Ju00#567>6:!2!23:.2%++2OS!8E%8I8I2J,K#LSKO%0A0A30F*G!HOHLhuU->->-C'DEL15M8E--.5r:   r%   RMSNormc                   ,     e Zd Zd fd	Zd Zd Z xZS )
CsmRMSNormc                     t         |           t        j                  t	        j
                  |            | _        || _        y)z9
        CsmRMSNorm is equivalent to T5LayerNorm
        N)super__init__nn	Parameterr5   onesweightvariance_epsilon)selfhidden_sizeeps	__class__s      r;   rA   zCsmRMSNorm.__init__f   s1     	ll5::k#:; #r:   c                 "   |j                   }|j                  t        j                        }|j	                  d      j                  dd      }|t        j                  || j                  z         z  }| j                  |j                  |      z  S )Nr   T)keepdim)	dtypetor5   float32powmeanrsqrtrF   rE   )rG   r)   input_dtypevariances       r;   forwardzCsmRMSNorm.forwardn   sy    #))%((7 $$Q',,R,>%Ht?T?T4T(UU{{]--k:::r:   c                 ^    t        | j                  j                         d| j                   S )Nz, eps=)r8   rE   shaperF   rG   s    r;   
extra_reprzCsmRMSNorm.extra_repru   s*    ))*+6$2G2G1HIIr:   )gư>)r1   r2   r3   rA   rV   rZ   __classcell__rJ   s   @r;   r>   r>   d   s    $;Jr:   r>   c                   ~     e Zd ZU ej                  ed<   ddef fdZ ej                         e	d               Z
 xZS )CsmRotaryEmbeddinginv_freqconfigc                    t         |           t        |d      rUt        |j                  t
              r;|j                  j                  d|j                  j                  d            | _        nd| _        |j                  | _	        |j                  | _
        || _        t        | j                     | _        | j                  | j                  |      \  }| _        | j                  d|d       | j                   | _        y )Nrope_scaling	rope_typetypedefaultr_   F
persistent)r@   rA   hasattr
isinstancerb   dictgetrc   max_position_embeddingsmax_seq_len_cachedoriginal_max_seq_lenr`   r   rope_init_fnattention_scalingregister_bufferr_   original_inv_freq)rG   r`   devicer_   rJ   s       r;   rA   zCsmRotaryEmbedding.__init__|   s    6>*z&:M:Mt/T#0044[&BUBUBYBYZ`BabDN&DN"("@"@$*$B$B!/?+/+<+<T[[&+Q($(ZeD!%r:   c                 b   | j                   d d d d f   j                         j                  |j                  d   dd      j	                  |j
                        }|d d d d d f   j                         }t        |j
                  j                  t              r/|j
                  j                  dk7  r|j
                  j                  nd}t        j                  |d      5  |j                         |j                         z  j                  dd      }t        j                  ||fd	      }|j                         | j                  z  }|j                         | j                  z  }	d d d        j	                  |j                   
      	j	                  |j                   
      fS # 1 sw Y   AxY w)Nr   rL   r   mpscpuF)device_typeenabledr   dim)rN   )r_   floatexpandrX   rO   rs   ri   rd   strr5   autocast	transposecatcosrp   sinrN   )
rG   xposition_idsinv_freq_expandedposition_ids_expandedrw   freqsembr   r   s
             r;   rV   zCsmRotaryEmbedding.forward   sV    !MM$4-8>>@GGHZHZ[\H]_acdehhijiqiqr ,QaZ 8 > > @'1!((--'E!((--[`J`ahhmmfk^^UC 	5&,,.1F1L1L1NNYYZ[]^_E))UEN3C'')d444C'')d444C		5 vvAGGv$cff177f&;;;	5 	5s    BF%%F.N)r1   r2   r3   r5   Tensorr7   r    rA   no_gradr   rV   r[   r\   s   @r;   r^   r^   y   s=    ll/y /" U]]_<  <r:   r^   c                   $     e Zd Z fdZd Z xZS )CsmMLPc                    t         |           || _        |j                  | _        |j                  | _        t        j                  | j                  | j                  |j                        | _        t        j                  | j                  | j                  |j                        | _	        t        j                  | j                  | j                  |j                        | _
        t        |j                     | _        y )Nbias)r@   rA   r`   rH   intermediate_sizerB   Linearmlp_bias	gate_projup_proj	down_projr	   
hidden_actact_fnrG   r`   rJ   s     r;   rA   zCsmMLP.__init__   s    !--!'!9!94#3#3T5K5KRXRaRabyy!1!143I3IPVP_P_`4#9#94;K;KRXRaRabV../r:   c                     | j                  | j                  | j                  |            | j                  |      z        }|S r   )r   r   r   r   )rG   r   r   s      r;   rV   zCsmMLP.forward   s6    NN4;;t~~a/@#ADLLQRO#ST	r:   r1   r2   r3   rA   rV   r[   r\   s   @r;   r   r      s    0r:   r   c                     | dd| j                   d   dz  f   }| d| j                   d   dz  df   }t        j                  | |fd      S )z*Rotates half the hidden dims of the input..NrL   r   ry   )rX   r5   r   )r   x1x2s      r;   rotate_halfr      sZ    	
3"!''"+"""	#B	
3q ""	#B99rc2YB''r:   c                     |j                  |      }|j                  |      }| |z  t        |       |z  z   }||z  t        |      |z  z   }||fS )a  Applies Rotary Position Embedding to the query and key tensors.

    Args:
        q (`torch.Tensor`): The query tensor.
        k (`torch.Tensor`): The key tensor.
        cos (`torch.Tensor`): The cosine part of the rotary embedding.
        sin (`torch.Tensor`): The sine part of the rotary embedding.
        position_ids (`torch.Tensor`, *optional*):
            Deprecated and unused.
        unsqueeze_dim (`int`, *optional*, defaults to 1):
            The 'unsqueeze_dim' argument specifies the dimension along which to unsqueeze cos[position_ids] and
            sin[position_ids] so that they can be properly broadcasted to the dimensions of q and k. For example, note
            that cos[position_ids] and sin[position_ids] have the shape [batch_size, seq_len, head_dim]. Then, if q and
            k have the shape [batch_size, heads, seq_len, head_dim], then setting unsqueeze_dim=1 makes
            cos[position_ids] and sin[position_ids] broadcastable to the shapes of q and k. Similarly, if q and k have
            the shape [batch_size, seq_len, heads, head_dim], then set unsqueeze_dim=2.
    Returns:
        `tuple(torch.Tensor)` comprising of the query and key tensors rotated using the Rotary Position Embedding.
    )	unsqueezer   )qkr   r   r   unsqueeze_dimq_embedk_embeds           r;   apply_rotary_pos_embr      sY    ( --
&C
--
&C3w;q>C/0G3w;q>C/0GGr:   r)   n_repreturnc                     | j                   \  }}}}|dk(  r| S | dddddddddf   j                  |||||      } | j                  |||z  ||      S )z
    This is the equivalent of torch.repeat_interleave(x, dim=1, repeats=n_rep). The hidden states go from (batch,
    num_key_value_heads, seqlen, head_dim) to (batch, num_attention_heads, seqlen, head_dim)
    r   N)rX   r|   reshape)r)   r   batchnum_key_value_headsslenhead_dims         r;   	repeat_kvr      so    
 2?1D1D.Ehz!!Qa"23::5BUW\^bdlmM  (;e(CT8TTr:   modulequerykeyvalueattention_maskscalingdropoutkwargsc                 T   t        || j                        }t        || j                        }	t        j                  ||j	                  dd            |z  }
|#|d d d d d d d |j
                  d   f   }|
|z   }
t        j                  j                  |
dt        j                        j                  |j                        }
t        j                  j                  |
|| j                        }
t        j                  |
|	      }|j	                  dd      j                         }||
fS )Nr   r   rL   )rz   rN   )ptrainingr   )r   num_key_value_groupsr5   matmulr   rX   rB   
functionalsoftmaxrP   rO   rN   r   r   
contiguous)r   r   r   r   r   r   r   r   
key_statesvalue_statesattn_weightscausal_maskattn_outputs                r;   eager_attention_forwardr      s    3 ; ;<JUF$?$?@L<<z';';Aq'ABWLL!$Q1.D
0@0@0D.D%DE#k1==((2U]](SVVW\WbWbcL==((6??([L,,|\:K''1-88:K$$r:   c                   *    e Zd ZdZdedef fdZ eddd      	 	 dd	ej                  d
e
ej                  ej                  f   deej                     dee   deej                     dee   de
ej                  ej                  f   fd       Z xZS )CsmAttentionz=Multi-headed attention from 'Attention Is All You Need' paperr`   	layer_idxc                 d   t         |           || _        || _        t	        |d|j
                  |j                  z        | _        |j                  |j                  z  | _	        | j                  dz  | _
        |j                  | _        d| _        t        j                  |j
                  |j                  | j                  z  |j                        | _        t        j                  |j
                  |j                  | j                  z  |j                        | _        t        j                  |j
                  |j                  | j                  z  |j                        | _        t        j                  |j                  | j                  z  |j
                  |j                        | _        y )Nr   g      Tr   )r@   rA   r`   r   getattrrH   num_attention_headsr   r   r   r   attention_dropout	is_causalrB   r   attention_biasq_projk_projv_projo_projrG   r`   r   rJ   s      r;   rA   zCsmAttention.__init__   sM   "
F4F4F&JdJd4de$*$>$>&B\B\$\!}}d*!'!9!9ii : :T]] JQWQfQf
 ii : :T]] JQWQfQf
 ii : :T]] JQWQfQf
 ii&&68J8JQWQfQf
r:   past_key_valuer(   4.58new_nameversionr)   position_embeddingsr   cache_positionr   r   c                 4   |j                   d d }g |d| j                  }| j                  |      j                  |      j	                  dd      }	| j                  |      j                  |      j	                  dd      }
| j                  |      j                  |      j	                  dd      }|\  }}t        |	|
||      \  }	}
|'|||d}|j                  |
|| j                  |      \  }
}t        }| j                  j                  dk7  rt        | j                  j                     } || |	|
||f| j                  sdn| j                  | j                   d|\  }} |j"                  g |d j%                         }| j'                  |      }||fS )NrL   r   r   )r   r   r   eager        )r   r   )rX   r   r   viewr   r   r   r   updater   r   r`   _attn_implementationr   r   r   r   r   r   r   )rG   r)   r   r   r(   r   r   input_shapehidden_shapequery_statesr   r   r   r   cache_kwargsattention_interfacer   r   s                     r;   rV   zCsmAttention.forward  s    $))#2.88b8$--8{{=166|DNNqRST[[/44\BLLQPQR
{{=166|DNNqRST&S#7jRUWZ#[ j&#&snUL'6'='=j,X\XfXfht'u$J(?;;++w6"9$++:Z:Z"[$7	%
  $}}C$2H2HLL	%
 	%
!\ *k));;;;FFHkk+.L((r:   )NN)r1   r2   r3   r4   r    intrA   r   r5   r   r8   r   r
   
LongTensorr   r   rV   r[   r\   s   @r;   r   r      s    G
y 
S 
. %0A6R ,059))||)) #5<<#=>)) !.	))
 "%)) !!1!12)) +,)) 
u||U\\)	*)) S))r:   r   c                   >    e Zd Zdedef fdZ eddd      	 	 	 	 	 	 ddej                  d	e	ej                     d
e	ej                     de	e   de	e   de	ej                     de	eej                  ej                  f      dee   dej                  fd       Z xZS )CsmDecoderLayerr`   r   c                     t         |           |j                  | _        t        ||      | _        t        |      | _        t        |j                  |j                        | _	        t        |j                  |j                        | _
        y )N)r`   r   rI   )r@   rA   rH   r   	self_attnr   mlpr>   rms_norm_epsinput_layernormpost_attention_layernormr   s      r;   rA   zCsmDecoderLayer.__init__=  sk    !--%VyI&>)&*<*<&BUBUV(263E3E6K^K^(_%r:   r   r(   r   r   r)   r   r   	use_cacher   r   r   r   c                     |}	| j                  |      } | j                  d|||||||d|\  }}
|	|z   }|}	| j                  |      }| j                  |      }|	|z   }|S )N)r)   r   r   r(   r   r   r   r9   )r   r   r   r   )rG   r)   r   r   r(   r   r   r   r   residual_s              r;   rV   zCsmDecoderLayer.forwardG  s     !,,];)4>> 	
')%+) 3	
 	
q !=0 !55mD/ =0r:   )NNNFNN)r1   r2   r3   r    r   rA   r   r5   r   r   r   r
   boolr8   r   r   rV   r[   r\   s   @r;   r   r   <  s    `y `S ` %0A6R 2637+/$)59KO|| !. u//0	
 "% D> !!1!12 &eELL%,,,F&GH +, 
 Sr:   r   z[
    The bare Csm Model outputting raw hidden-states without any specific head on top.
    c                   X     e Zd ZU eed<   dZdZdgZdgZdZ	dZ
dZdZeedZ fdZ xZS )CsmPreTrainedModelr`   modelTr   r(   )r)   r*   c                     t         |   |       t        |t              r^|j                  }t        |dz
        D ]@  }|j                  j                  |   j                  d| j                  j                         B y y )Nr   r   )rR   std)r@   _init_weightsri   CsmCodebooksHeadnum_codebooksrangerE   datanormal_r`   initializer_range)rG   r   r   irJ   s       r;   r   z CsmPreTrainedModel._init_weights  sr    f%f./"00M=1,- [""1%--3DKK<Y<Y-Z[ 0r:   )r1   r2   r3   r    r7   base_model_prefixsupports_gradient_checkpointing_no_split_modules_skip_keys_device_placement_supports_flash_attn_supports_sdpa_can_compile_fullgraph_supports_attention_backendr   r   _can_record_outputsr   r[   r\   s   @r;   r   r   j  s\     &*#*+#4"5N ""&("
[ [r:   r   c                   2    e Zd ZU eed<    fdZee	 	 	 	 	 	 	 	 ddej                  de
ej                     de
ej                     de
ej                     de
e   de
ej                     d	e
e   d
e
ej                     dee   deeef   fd              Z xZS )CsmDepthDecoderModelr`   c           	      r   t         |   |       |j                  | _        |j                  | _        t        j                  |j                  |j                  z  |j                        | _	        t        j                  t        |j                        D cg c]  }t        ||       c}      | _        t        |j                   |j"                        | _        t'        |      | _        d| _        t        j,                  |j                  |j                   d      | _        | j1                          y c c}w )Nr   r`   Fr   )r@   rA   pad_token_idpadding_idx
vocab_sizerB   	Embeddingr   backbone_hidden_sizeembed_tokens
ModuleListr   num_hidden_layersr   layersr>   rH   r   normr^   
rotary_embgradient_checkpointingr   inputs_embeds_projector	post_initr   s      r;   rA   zCsmDepthDecoderModel.__init__  s     !.. ++LL&*>*>ARAR*RU[UpUpqmmAFvG_G_A`aI_VY/a
 v11v7J7JK	,F;&+#')yy1L1LfN`N`gl'm$ 	 bs   D4	input_idsbackbone_last_hidden_stater   r   r(   inputs_embedsr   r   r   r   c	                    |5t         j                  j                         st        j	                  d       d}|du |duz  rt        d      |r|t        | j                        }|i||j                         nd}
||j                  d   n|j                  d   }||j                  n|j                  }t        j                  |
|
|z   |      }|t        j                  |dz
  d      }|| j                  z  }| j                  ||z         }|d   dk(  }|
||dddf<   n5t         j                  j                         s|rt        j                  d	       | j!                  |      }t#        | j                  |||||
      }|}|j%                  d      }| j'                  ||      }| j(                  d| j                  j*                   D ]  } ||f||||||d|	} | j-                  |      }t/        ||r|      S d      S )aJ  
        backbone_last_hidden_state (`torch.FloatTensor` of shape `(batch_size, backbone_hidden_size)`, *optional*):
            The last hidden state of the backbone model. Such input is required when the first codebook token (the one generated by the backbone model)
            is provided in the `input_ids` argument.
        NzCustom `position_ids` were provided but will be ignored. CSM depth decoder automatically determines position_ids from `cache_position` and as it requires them to be identical across the batch, the provided position_ids will be ignored.z;You must specify exactly one of input_ids or inputs_embeds.r  r   r   rs   )minzvWhen the first codebook token is provided, `backbone_last_hidden_state` should also be provided for correct inference.r`   input_embedsr   r   r(   r   )r   r   r(   r   r   r   last_hidden_stater(   )r5   compileris_compilingloggerwarning_once
ValueErrorr   r`   get_seq_lengthrX   rs   arangeclampr  r  warningr  r   r   r  r  r  r  r   )rG   r   r!  r   r   r(   r"  r   r   r   past_seen_tokensinputs_seq_lengthrs   codebook_idxsoffsetinput_ids_are_first_codebookr   r)   r   decoder_layers                       r;   rV   zCsmDepthDecoderModel.forward  sE   & #ENN,G,G,IM  L-t";<Z[[0*$++>O!CRC^==?de:G:S 3 3A 6YbYhYhijYk-:-F]))IL\L\F"\\*:<LO`<`iopN !KK(:BM"T__4F --i&.@AM+9!+<+A()5&@ad#~~2249UNN Q 44]C(;;&))+%
 & &//2"oom\J![[)H4;;+H+HI 
	M)	*) /#-$7	 	M
	 		-0&+/8O
 	
>B
 	
r:   )NNNNNNNN)r1   r2   r3   r!   r7   rA   r   r   r5   r   r   r6   r   r
   r   r   r   r   r8   r   rV   r[   r\   s   @r;   r  r    s   !!   '+BF1537+/59$(59R
##R
 %-U->->$?R
 !.	R

 u//0R
 "%R
   1 12R
 D>R
 !!1!12R
 +,R
 
u--	.R
  R
r:   r  c                   &     e Zd Z fdZddZ xZS )r   c                     t         |           || _        t        j                  t        j                  | j                  dz
  ||            | _        y Nr   )r@   rA   r   rB   rC   r5   emptyrE   )rG   rH   r   r  rJ   s       r;   rA   zCsmCodebooksHead.__init__  s?    *ll5;;t/A/AA/E{T^#_`r:   c           
         |2|j                   d   }| j                  t        j                  |         }n|dz
  }| j                  |   }t	        |j                   d         D cg c]9  }t
        j                  j                  |d d |d d f   ||   j                        ; }}t        j                  |d      }|S c c}w )Nr   r   ry   )
rX   rE   r5   r0  r   rB   r   linearTstack)rG   r)   r   
seq_lengthcodebook_weightr5  codebook_idxs          r;   rV   zCsmCodebooksHead.forward  s    !&,,Q/J"kk%,,z*BCO*Q.M"kk-8O !&o&;&;A&> ?
 MM  q,/A!BOT`DaDcDcd
 
 Mq9
s   #>B<r   r   r\   s   @r;   r   r     s    a
r:   r   a$  
    The CsmDepthDecoder Model transformer, with a [`CsmCodebooksHead`] on top,
    which can be seen a position-specific language modeling head, allowing to use a different linear layer for each codebook
    (e.g. position 0 is the first codebook and uses the first codebook head, etc.)
    c                   ,    e Zd ZdZdZdZ fdZee	 	 	 	 	 	 	 	 	 	 dde	j                  dee	j                     dee	j                     dee	j                     deeeee	j                     f      dee	j                     d	ee	j                     d
ee   dee	j                     deee	j                  f   dee   deeef   fd              Z	 	 	 	 dde	j                  dee   dee	j                     dee	j                     dee	j                     f
 fdZ xZS )CsmDepthDecoderForCausalLMNc                     t         |   |       t        |      | _        |j                  | _        t        |j                  |j                  |j                        | _        | j                          y r   )
r@   rA   r  r   r  r   rH   r   codebooks_headr  r   s     r;   rA   z#CsmDepthDecoderForCausalLM.__init__  sY     )&1
 ++.v/A/A6CWCWY_YjYjk 	r:   r   r!  r   r   r(   r"  labelsr   r   logits_to_keepr   r   c                     | j                   d||||||||	d|}|d   }t        |
t              r |
dk(  rt        dd      }nt        |
 d      }n|
}| j	                  |dd|ddf   |	|	|   nd      }|j                         }d}|B|dddf   j                         } | j                  d|d| j                  j                  |d|}t        |||j                  |j                  |j                        S )	a  
        backbone_last_hidden_state (`torch.FloatTensor` of shape `(batch_size, backbone_hidden_size)`, *optional*):
            The last hidden state of the backbone model. Such input is required when the first codebook token (the one generated by the backbone model)
            is provided in the `input_ids` argument.
        labels (`torch.LongTensor` of shape `(batch_size, sequence_length)`, *optional*):
            Labels for computing the masked language modeling loss. Indices should either be in `[0, ...,
            config.vocab_size]` or -100 (see `input_ids` docstring). Tokens with indices set to `-100` are ignored
            (masked), the loss is only computed for the tokens with labels in `[0, ..., config.vocab_size]`.
        )r   r!  r   r   r(   r"  r   r   r   r   N.)r'   rH  r  shift_labels)r&   r'   r(   r)   r*   r9   )r   ri   r   slicerG  r   loss_functionr`   r  r   r(   r)   r*   )rG   r   r!  r   r   r(   r"  rH  r   r   rI  r   outputsr)   slice_indicesr'   r&   rK  s                     r;   rV   z"CsmDepthDecoderForCausalLM.forward!  s;   2 $** 

'A)%+')

 

  
nc*" %a %~ot <*M$$!]A-.Q_Qk}0Mqu
 ""$!#qr'?557L%4%% dt{{7M7M\hlrD &#33!//))
 	
r:   c                     t        	|   |||||fi |}|d   d   dk(  }|s|j                  d       |j                  d       |S )Nr   r   r!  r   )r@   prepare_inputs_for_generationpop)
rG   r   r(   r   r"  r   r   model_inputsis_first_generation_steprJ   s
            r;   rQ  z8CsmDepthDecoderForCausalLM.prepare_inputs_for_generatione  sg     w<~
Y_
 $00@#A!#D#I '9: 	(r:   )
NNNNNNNNNr   NNNN)r1   r2   r3   _tied_weights_keys_tp_plan_pp_planrA   r   r   r5   r   r   r6   r   r   r
   listr   r   r   r   r8   r   rV   rQ  r[   r\   s   @r;   rE  rE    s    HH  '+BF1537KO59-1$(5934@
##@
 %-U->->$?@
 !.	@

 u//0@
 "%tE4E4E/F(F"GH@
   1 12@
 ))*@
 D>@
 !!1!12@
 c5<</0@
 +,@
 
u,,	-@
  @
J ,0595959## "% !!1!12	
   1 12 !!1!12 r:   rE  c                   $     e Zd Z fdZd Z xZS )CsmBackboneModelEmbeddingsc                    t         |           t        j                  |j                  |j
                  z  |j                        | _        | j                  dt        j                  |j                        |j
                  z  d       y )Naudio_tokens_offsetsFrf   )r@   rA   rB   r  r   r  rH   embed_audio_tokensrq   r5   r0  r   s     r;   rA   z#CsmBackboneModelEmbeddings.__init__}  sn    "$,,0D0DvGXGX0X[a[m[m"n"ELL1E1E$FIZIZ$Zgl 	 	
r:   c                 f    | j                  || j                  z         }|j                  d      }|S )Nr   ry   )r^  r]  sum)rG   r   r'  s      r;   rV   z"CsmBackboneModelEmbeddings.forward  s6    ..y4;T;T/TU#''A'.r:   r   r\   s   @r;   r[  r[  |  s    
r:   r[  c                       e Zd Z fdZee	 	 	 	 	 	 	 ddeej                     deej                     deej                     dee
   deej                     deej                     dee   d	ee   d
efd              Z xZS )CsmBackboneModelc           	         t         |   |       |j                  | _        |j                  | _        t        |      | _        t        j                  t        |j                        D cg c]  }t        ||       c}      | _        t        |j                  |j                        | _        t#        |      | _        d| _        | j)                          y c c}w )Nr   r  F)r@   rA   r  r  r  r[  r  rB   r  r   r  r   r  r>   rH   r   r  r^   r  r  r  r   s      r;   rA   zCsmBackboneModel.__init__  s     !.. ++6v>mmAFvG_G_A`aI_VY/a
 v11v7J7JK	,F;&+# 	 bs   )Cr   r   r   r(   r"  r   r   r   r   c           
      B   |du |duz  rt        d      || j                  |      }|r|t        | j                        }|F||j	                         nd}	t        j                  |	|	|j                  d   z   |j                        }||j                  d      }t        | j                  |||||      }
|}| j                  ||      }| j                  d| j                  j                   D ]  } ||f|
||||d|} | j                  |      }t        ||	      S )
a&  
        input_ids (`torch.LongTensor` of shape `(batch_size, sequence_length, num_codebooks) or (batch_size, sequence_length)`):
            1. (batch_size, sequence_length): corresponds to the input sequence prepared with the processor from the text prompt. Such input
            requires `input_values` to be provided so that audio can be encoded in codebook tokens and then merged with the text tokens.

            2. (batch_size, sequence_length, num_codebooks): codebook tokens generated during the autoregressive decoding. Such input is not meant to be used by end users.

            Indices can be obtained using [`AutoTokenizer`]. See [`PreTrainedTokenizer.encode`] and
            [`PreTrainedTokenizer.__call__`] for details.

            [What are input IDs?](../glossary#input-ids)
        Nz:You must specify exactly one of input_ids or inputs_embedsr  r   r   r$  r&  )r   r   r(   r   r   r(  )r.  r  r   r`   r/  r5   r0  rX   rs   r   r   r  r  r  r  r   )rG   r   r   r   r(   r"  r   r   r   r3  r   r)   r   r8  s                 r;   rV   zCsmBackboneModel.forward  s[   2 -t";<YZZ *.*;*;I*FM0*$++>O!CRC^==?de+0<< "2]5H5H5K"KTaThTh,N )33A6L(;;&))+%
 &"oom\J![[)H4;;+H+HI 		M)*) /-$7 M		 		-0&++
 	
r:   )NNNNNNN)r1   r2   r3   rA   r   r   r   r5   r   r   r
   r6   r   r   r   r   rV   r[   r\   s   @r;   rb  rb    s      151537+/5959$(D
E,,-D
 !.D
 u//0	D

 "%D
   1 12D
 !!1!12D
 D>D
 +,D
 
!D
  D
r:   rb  z
    The Csm model consists of two llama-like auto-regressive transformer models: a backbone model that predicts the first codebook token and a depth decoder that predicts the other codebook tokens.
    c                        e Zd ZddgZ fdZd Zd Zd Ze fd       Z	 fdZ
	 	 	 	 dd	eej                     d
eej                     deej                     deej                     deej                     f
dZ	 	 	 	 dd	ej                  dee   deej                     deej"                     deej                     f
 fdZee	 	 	 	 	 	 	 	 	 	 	 dd	ej                  d
eej                     deej                     deej                     deej                     deeeeej"                     f      deej"                     deej                     dee   deej                     deeej                  f   dee   deeef   fd              Z xZS )CsmForConditionalGenerationz5backbone_model.embed_tokens.embed_audio_tokens.weightz'depth_decoder.model.embed_tokens.weightc                    t         |   |       |j                  | _        t        j                  |j
                  |j                  d      | _        t        j                  |j                  |j
                        | _	        t        j                  |      | _        t        j                  |j                        | _        t!        j"                  |j$                        | _        | j)                          y )NFr   )r@   rA   r  rB   r   rH   lm_headr  text_vocab_sizeembed_text_tokensrb  _from_configbackbone_modelrE  depth_decoder_configdepth_decoderr   from_configcodec_configcodec_modelr  r   s     r;   rA   z$CsmForConditionalGeneration.__init__  s      ++yy!3!3V5F5FUS!#f.D.DfFXFX!Y.;;FC7DDVE`E`a$001D1DEr:   c                 .    | j                   j                  S r   rl  r  rY   s    r;   get_input_embeddingsz0CsmForConditionalGeneration.get_input_embeddings  s    ""///r:   c                 &    || j                   _        y r   rs  )rG   r   s     r;   set_input_embeddingsz0CsmForConditionalGeneration.set_input_embeddings  s    +0(r:   c                     | j                   j                  rO| j                  | j                  j                  j
                  | j                  j                  j                         y y r   )r`   tie_codebooks_embeddings_tie_or_clone_weightsrl  r  r^  rn  r   rY   s    r;   _tie_weightsz(CsmForConditionalGeneration._tie_weights  sL    ;;//&&##00CC""((55 0r:   c                    |j                  dd      rt        
|   |i |\  }}nt        
|   |i |}d}t        |      }t	        |j
                        j                         D ci c]  \  }}|j                  |      r||d  | }	}}t	        |j                  j
                        j                  ddi|	       |	D ]  }t        |j
                  ||z           d|v r|fS |S c c}}w )Noutput_loading_infoFdepth_decoder__from_model_config)rk   r@   from_pretrainedlenvarsgeneration_configitems
startswithrn  r   delattr)clsargsr   r   loading_infoprefix
prefix_lenattrr   depth_decoder_attrsrJ   s             r;   r  z+CsmForConditionalGeneration.from_pretrained  s   ::+U3"''"94"J6"JE<G+T<V<E "[
  $E$;$;<BBD
ev& u$
 
 	U  223::<PRW;o[n;op ( 	<DE++Vd];	< !F*,&&L
s   )!C)c                     d}| j                   j                  j                         }|j                  dd        |j	                         D ]  \  }}t        | j                  ||z   |       ! t        |   |i | y )Nr}  transformers_version)rn  r  to_diff_dictrR  r  setattrr@   save_pretrained)rG   r  r   r  r  r  r   rJ   s          r;   r  z+CsmForConditionalGeneration.save_pretrained!  s|    !"00BBOOQ 6=.446 	BKD%D**FTM5A	B 	00r:   r   input_valuesinput_values_cutoffsrH  r   c                    | j                  |      }|Ut        j                  j                  |d      }||dk\     j	                         }||dkD     }t        j                  |j                         |j                        j                  t        |      d      }||j                  d      k  }t        j                         5  g }t        ||      D ]  \  }	}
|
|
dk\     }
t        |
j                  d   dz
        D ]r  }|
|   }|
|dz      }|	d||f   }| j                   j#                  |j                  d            }|j$                  j'                  dd      }|j)                  |d          t  t        d |D              }t        j*                  |D cg c]6  }t        j                  j                  |ddd||j                  d   z
  f      8 c}      }| j                   j-                  |      }ddd       | j.                  j0                  }||k(  }| j2                  j5                        }|   ||<   t        j6                  dd| j.                  j8                  f|j                  t
        j:                  	      | j.                  j<                  z  }| j2                  j5                  |      j?                  d      }|| j.                  j@                  k(  }|jC                  |jE                         d      ||<   |j|j                  d      jC                  dd| j.                  j8                        }||   ||<   |||<   |d
k(  jG                  d      }d||d   |d   ddf<   |}||dS c c}w # 1 sw Y   xY w)a  
        Merges the input_ids and input_values to produce a single inputs_embeds tensor:
        1 - Infers the codec model on the input_values to retreive codebook token.
        2 - Embeds codebook tokens and places them at the correct positions in the inputs_embeds tensor.
        3 - If labels are provided, expands them to match codebook dimensions and position the target codebook tokens in the inputs_embeds tensor.

        Args:
            input_ids (`torch.Tensor` of shape `(batch_size, sequence_length)`):
                The input ids to embed.
            input_values (`torch.Tensor` of shape `(batch_size, channels, audio_sequence_length)`):
                The audio input values to embed.
            input_values_cutoffs (`torch.Tensor` of shape `(batch_size, max_num_audio)`):
                The cutoffs of the audio input values relative to its batch index, padded with -1 when no audio.
        Nr   r   r   r$  rL   r   .c              3   :   K   | ]  }|j                   d      yw)r   N)rX   ).0els     r;   	<genexpr>zQCsmForConditionalGeneration._merge_input_ids_with_input_values.<locals>.<genexpr>[  s     &Orrxx{&Os   )rs   rN   iTas_tuple)r"  rH  )$rj  rB   r   paddiffr5   r0  maxrs   r|   r  r   r   zipr   rX   rq  encodeaudio_codesr   appendr@  get_audio_codes_maskr`   audio_token_idrl  r  rD   r   longcodebook_eos_token_idsqueezeaudio_eos_token_idrepeatr`  nonzero)rG   r   r  r  rH  r"  audio_lengthsinput_values_maskaudio_tokens_listbatch_input_valuesbatch_input_values_cutoffsr  	start_idxend_idxaudio_batchcodec_outputscodebook_idsmax_audio_framesr  batched_audio_token_idsaudio_codes_maskr  audio_token_maskaudio_embedsaudio_eos_frame_idsaudio_eos_embedsaudio_eos_token_masklabels_expanded depth_decoder_ignore_frames_idxss                                r;   "_merge_input_ids_with_input_valuesz>CsmForConditionalGeneration._merge_input_ids_with_input_values+  s   * ..y9##%==#4#45I6#R 01E1JKPPRM)-!*;<M %-A-E-E-GP\PcPc d k kM"B! !2M4K4KA4N N
  \$&!FI,XlFm BB&(B1KLfjkLk1l."#=#C#CA#F#JK B$>q$A	"<QU"C&8i>O9O&P(,(8(8(?(?@U@UVW@X(Y'4'@'@'J'J1b'Q)00aABB $'&O=N&O#O */++`qrZ\R]]&&rAq!5EQR5S+TUr+' $(#3#3#H#HIZ#[ !\$ "[[77N(N:..;;<STL.:;K.LM*+ 

Aq$++";";<YEUEU]b]g]gh++334    $22??@ST\\]^_#,0N0N#N 2B2I2IJ^JbJbJdfg2hM./ !"("2"22"6"="=aDKKD]D]"^4KL\4] 018K 454:dN3K3KUY3K3Z0pt @ CEefgEhjkjl lm(!.&AA= s\ \s   CM4;M/
"M4/M44M>r(   r   r"  r   c           	      0   t        	|   d	|||||d|}|}|j                  dk(  rn|j                  d      ]| j	                  ||j                  d      |j                  d      |j                  d            }|j                  |d   |d   d d       |S )
N)r   r(   r   r"  r   r   r"  r  r  rH  )r   r  r  rH  )r"  rH  r   r9   )r@   rQ  ndimrk   r  r   )
rG   r   r(   r   r"  r   r   rS  merged_inputsrJ   s
            r;   rQ  z9CsmForConditionalGeneration.prepare_inputs_for_generation}  s     w< 
+)')
 
  Y^^q%8\=M=Mo=^=f CC##ZZ7%+ZZ0F%Gzz(+	 D M "/"@MZbLcrvw r:   r   r   rI  r   c                    |/|j                   dk(  r | j                  ||||      }|d   }|d   }d} | j                  d||||||	|
d|}|d   }t        |t              rt        | d      n|}| j                  |dd|ddf         }d}d}d}d}||dddddf   } | j                  d||| j                  j                  d|}|ddddddf   d	k(  j                  d
       }||   dd| j                  j                  dz
  f   }t        j                  j                  |dd      }|j                  d      }||d   |d   dz
  ddf   }||   } | j                   d|||	d|d|}|j"                  }||z   }t%        |||||j&                  |j(                  |j*                  ||j,                  nd||j&                  nd||j(                  nd||j*                        S d      S )a  
        input_ids (`torch.LongTensor` of shape `(batch_size, sequence_length, num_codebooks) or (batch_size, sequence_length)`):
            1. (batch_size, sequence_length): corresponds to the input sequence prepared with the processor from the text prompt. Such input
            requires `input_values` to be provided so that audio can be encoded in codebook tokens and then merged with the text tokens.

            2. (batch_size, sequence_length, num_codebooks): codebook tokens generated during the autoregressive decoding. Such input is not meant to be used by end users.

            Indices can be obtained using [`AutoTokenizer`]. See [`PreTrainedTokenizer.encode`] and
            [`PreTrainedTokenizer.__call__`] for details.

            [What are input IDs?](../glossary#input-ids)
        input_values_cutoffs (`torch.Tensor` of shape `(batch_size, max_num_audio)`, *optional*):
            Specify the end positions of audio segments within each batch entry, relative to the concatenated audio input.
            If a batch entry has fewer segments than the maximum, it is padded with -1. For example, in a batch of 2 sequences
            where the first contains 2 audio segments of length l1, and the second contains 1 audio segment of length l2,
            the input_values_cutoffs would be: [[l1, 2 * l1], [l2, -1]].
        labels (`torch.LongTensor` of shape `(batch_size, sequence_length)`, *optional*):
            Labels for computing the masked language modeling loss. Indices should be in `[config.audio_token_id, -100, -101]`.
            Requires targeted `input_values` to be provided as audio tokens will be inferred from it using the `codec_model`.
            - `config.audio_token_id` indicates an audio frames (considering sequence length elements as frames)
            - `-100` will be ignored in the loss computation
            - `-101` indicates the audio frame will be used only for the backbone model (using the first codebook token as labels)

            Such labels can be prepared using `output_labels=True` when calling [`CsmProcessor`].
        logits_to_keep (`int` or `torch.Tensor`, *optional*):
            Kept for compatibility. Does not support another value than:
            1. `0`, which is equivalent to keeping all logits, used in the training regime
            2. `1`, which is equivalent to keeping only the last logit, used in the generation regime

        Example:

        ```python
        >>> import torch
        >>> from transformers import CsmForConditionalGeneration, AutoProcessor
        >>> from datasets import load_dataset, Audio

        >>> model_id = "sesame/csm-1b"
        >>> torch_device = "cuda" if torch.cuda.is_available() else "cpu"

        >>> processor = AutoProcessor.from_pretrained(model_id)

        >>> ds = load_dataset("hf-internal-testing/dailytalk-dummy", split="train")
        >>> # ensure the audio is 24kHz
        >>> ds = ds.cast_column("audio", Audio(sampling_rate=24000))

        >>> conversation = []
        >>> # prepare a conversation with text and corresponding audio
        >>> for text, audio, speaker_id in zip(ds[:4]["text"], ds[:4]["audio"], ds[:4]["speaker_id"]):
        ...     conversation.append(
        ...         {
        ...             "role": f"{speaker_id}",
        ...             "content": [{"type": "text", "text": text}, {"type": "audio", "path": audio["array"]}],
        ...         }
        ...     )

        >>> inputs = processor.apply_chat_template(
        ...     conversation,
        ...     tokenize=True,
        ...     return_dict=True,
        ...     output_labels=True,
        ... ).to(torch_device)

        >>> model = CsmForConditionalGeneration.from_pretrained(model_id, device_map=torch_device)
        >>> output = model(**inputs)
        >>> output.loss.backward()
        ```Nr   r"  rH  )r   r   r   r(   r"  r   r   r   )r'   rH  r  r   r  rL   ry   .r  )r   Tr  )r   r!  r   return_dictrH  )r&   r0   r+   r'   r(   r)   r*   r,   r-   r.   r/   r9   )r  r  rl  ri   r   rL  rh  rM  r`   r  allr   rB   r   r  r  rn  r&   r%   r(   r)   r*   r'   )rG   r   r  r   r  r   r(   r"  rH  r   r   rI  r   r  backbone_outputsbackbone_hidden_statesrO  backbone_logitsr&   r0   r+   depth_decoder_outputsbackbone_labels
train_maskdepth_decoder_input_ids
train_idxsbackbone_last_hidden_statesdepth_decoder_labelss                               r;   rV   z#CsmForConditionalGeneration.forward  s   f  Y^^q%8 CC<)=vM */:M"8,FI.4.. 	
)%+')	
 	
 "2!!48B>SV8W~ot4]k,,'=aPQ>Q'RS! $$Q1WoO.D.. &4;;KaKaekM "!Q(+t388R8@@J&,Z&8>]@Y@Y\]@]>]9]&^#&(mm&7&78OQW_`&7&a##++T+:J*@APZ[\P]`aPacdAd*e'#)*#5 $6D$6$6 %1+F# +% %! "7!;!; #55D '1",<<*88'22AVAb!6!=!=hl$0 +@*O*O$0 )>(K(KI^Ij%:%E%E
 	
 qu
 	
r:   rU  )NNNNNNNNNNr   )r1   r2   r3   rV  rA   rt  rv  rz  classmethodr  r  r   r5   r   r  r   r
   r6   rQ  r   r   r   rY  r   r   r   r   r8   r%   rV   r[   r\   s   @r;   rf  rf    s    	@1
01  41 -1/37;)-PBELL)PB u||,PB 'u||4	PB
 &PB 
%,,	PBj ,0595959## "% !!1!12	
   1 12 !!1!12>  '+/3157;37KO59-1$(5934[
##[
 u||,[
 !.	[

 'u||4[
 u//0[
 "%tE4E4E/F(F"GH[
   1 12[
 ))*[
 D>[
 !!1!12[
 c5<</0[
 +,[
 
u''	([
  [
r:   rf  )r   rb  r  rE  rf  r;  )r   )Kdataclassesr   typingr   r   r   r5   torch.nnrB   transformers.utils.genericr   activationsr	   cache_utilsr
   r   
generationr   integrationsr   masking_utilsr   modeling_layersr   modeling_outputsr   r   modeling_rope_utilsr   r   modeling_utilsr   r   processing_utilsr   utilsr   r   r   r   r   utils.deprecationr   autor   configuration_csmr    r!   generation_csmr"   
get_loggerr1   r,  r%   Moduler>   r^   r   r   r   r   r   r   r{   r   r   r   r   r  r   rE  r[  rb  rf  __all__r9   r:   r;   <module>r     s  , " , ,   9 ! . ) 7 / 9 O K F & _ _ 0  ? . 
		H	% 
)6 )6 )6X Y'J J (J(!< !<HRYY  (6	UU\\ 	U# 	U%,, 	U& %II%<<% 
% <<	%
 U\\*% % % '(%4D)299 D)N+0 +\ 
 [ [ [4 g
- g
 g
Tryy . f!3_ ffR  V
) V
 V
r 
P
"46H P

P
f
r:   