
    rh                     Z   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,m-Z- ddl.m/Z/  e(j`                  e1      Z2e e&d       G d de$                    Z3 ed       G d dejh                               Z5 G d dejh                        Z6 G d d ejh                        Z7d! Z8dFd"Z9d#ejt                  d$e;d%ejt                  fd&Z<	 dGd'ejh                  d(ejt                  d)ejt                  d*ejt                  d+eejt                     d,e=d-e=d.e"e%   fd/Z> G d0 d1ejh                        Z? G d2 d3e      Z@ e&d4      e& G d5 d6e                     ZAe& G d7 d8eA             ZB G d9 d:ejh                        ZC e&d;       G d< d=eAe             ZD G d> d?ejh                        ZEe& G d@ dAeA             ZF e&dB       G dC dDeAe/             ZGg dEZHy)H    )	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   )	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.   r/        w/var/www/html/ai-insurance-compliance-backend/venv/lib/python3.12/site-packages/transformers/models/csm/modeling_csm.pyr$   r$   1   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--.5r9   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	Parameterr4   onesweightvariance_epsilon)selfhidden_sizeeps	__class__s      r:   r@   zCsmRMSNorm.__init__e   s1     	ll5::k#:; #r9   c                 "   |j                   }|j                  t        j                        }|j	                  d      j                  dd      }|t        j                  || j                  z         z  }| j                  |j                  |      z  S )Nr   T)keepdim)	dtypetor4   float32powmeanrsqrtrE   rD   )rF   r(   input_dtypevariances       r:   forwardzCsmRMSNorm.forwardm   sy    #))%((7 $$Q',,R,>%Ht?T?T4T(UU{{]--k:::r9   c                 ^    t        | j                  j                         d| j                   S )Nz, eps=)r7   rD   shaperE   rF   s    r:   
extra_reprzCsmRMSNorm.extra_reprt   s*    ))*+6$2G2G1HIIr9   )gư>)r0   r1   r2   r@   rU   rY   __classcell__rI   s   @r:   r=   r=   c   s    $;Jr9   r=   c                   ^     e Zd Zddef fdZ ej                         ed               Z xZ	S )CsmRotaryEmbedding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defaultinv_freqF
persistent)r?   r@   hasattr
isinstancer`   dictgetra   max_position_embeddingsmax_seq_len_cachedoriginal_max_seq_lenr^   r   rope_init_fnattention_scalingregister_bufferrd   original_inv_freq)rF   r^   devicerd   rI   s       r:   r@   zCsmRotaryEmbedding.__init__y   s    6>*z&:M:Mt/T#0044[&BUBUBYBYZ`BabDN&DN"("@"@$*$B$B!/?+/+<+<T[[&+Q($(ZeD!%r9   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   rK   r   mpscpuF)device_typeenabledr   dim)rM   )rd   floatexpandrW   rN   rr   rh   rb   strr4   autocast	transposecatcosro   sinrM   )
rF   xposition_idsinv_freq_expandedposition_ids_expandedrv   freqsembr   r   s
             r:   rU   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)
r0   r1   r2   r   r@   r4   no_gradr   rU   rZ   r[   s   @r:   r]   r]   x   s3    /y /" U]]_<  <r9   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?   r@   r^   rG   intermediate_sizerA   Linearmlp_bias	gate_projup_proj	down_projr	   
hidden_actact_fnrF   r^   rI   s     r:   r@   zCsmMLP.__init__   s    !--!'!9!94#3#3T5K5KRXRaRabyy!1!143I3IPVP_P_`4#9#94;K;KRXRaRabV../r9   c                     | j                  | j                  | j                  |            | j                  |      z        }|S r   )r   r   r   r   )rF   r   r   s      r:   rU   zCsmMLP.forward   s6    NN4;;t~~a/@#ADLLQRO#ST	r9   r0   r1   r2   r@   rU   rZ   r[   s   @r:   r   r      s    0r9   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..NrK   r   rx   )rW   r4   r   )r   x1x2s      r:   rotate_halfr      sZ    	
3"!''"+"""	#B	
3q ""	#B99rc2YB''r9   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r9   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)rW   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Tr9   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   rK   )ry   rM   )ptrainingr   )r   num_key_value_groupsr4   matmulr~   rW   rA   
functionalsoftmaxrO   rN   rM   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$$r9   c                       e Zd ZdZdedef fdZ	 	 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?   r@   r^   r   getattrrG   num_attention_headsr   r   r   r   attention_dropout	is_causalrA   r   attention_biasq_projk_projv_projo_projrF   r^   r   rI   s      r:   r@   zCsmAttention.__init__   sM   "
F4F4F&JdJd4de$*$>$>&B\B\$\!}}d*!'!9!9ii : :T]] JQWQfQf
 ii : :T]] JQWQfQf
 ii : :T]] JQWQfQf
 ii&&68J8JQWQfQf
r9   r(   position_embeddingsr   past_key_value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 )NrK   r   r   )r   r   r   eager        )r   r   )rW   r   r   viewr~   r   r   r   updater   r   r^   _attn_implementationr   r   r   r   r   r   r   )rF   r(   r   r   r   r   r   input_shapehidden_shapequery_statesr   r   r   r   cache_kwargsattention_interfacer   r   s                     r:   rU   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'5'<'<ZW[WeWegs't$J(?;;++w6"9$++:Z:Z"[$7	%
  $}}C$2H2HLL	%
 	%
!\ *k));;;;FFHkk+.L((r9   )NN)r0   r1   r2   r3   r   intr@   r4   Tensorr7   r   r
   
LongTensorr   r   rU   rZ   r[   s   @r:   r   r      s    G
y 
S 
8 +/59))||)) #5<<#=>)) !.	))
 !)) !!1!12)) +,)) 
u||U\\)	*))r9   r   c                   (    e Zd Zdedef fdZ	 	 	 	 	 	 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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   rH   )r?   r@   rG   r   	self_attnr   mlpr=   rms_norm_epsinput_layernormpost_attention_layernormr   s      r:   r@   zCsmDecoderLayer.__init__9  sk    !--%VyI&>)&*<*<&BUBUV(263E3E6K^K^(_%r9   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   r8   )r   r   r   r   )rF   r(   r   r   r   r   r   r   r   residual_s              r:   rU   zCsmDecoderLayer.forwardC  s     !,,];)4>> 	
')%)) 3	
 	
q !=0 !55mD/ =0r9   )NNNFNN)r0   r1   r2   r   r   r@   r4   r   r   r   r
   boolr7   r   r   rU   rZ   r[   s   @r:   r   r   8  s    `y `S ` 2637*.$)59KO|| !. u//0	
 ! D> !!1!12 &eELL%,,,F&GH +, 
u||	r9   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   )rQ   std)r?   _init_weightsrh   CsmCodebooksHeadnum_codebooksrangerD   datanormal_r^   initializer_range)rF   r   r   irI   s       r:   r   z CsmPreTrainedModel._init_weights}  sr    f%f./"00M=1,- [""1%--3DKK<Y<Y-Z[ 0r9   )r0   r1   r2   r   r6   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   rZ   r[   s   @r:   r   r   e  s\     &*#*+#4"5N ""&("
[ [r9   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?   r@   pad_token_idpadding_idx
vocab_sizerA   	Embeddingr   backbone_hidden_sizeembed_tokens
ModuleListr   num_hidden_layersr   layersr=   rG   r   normr]   
rotary_embgradient_checkpointingr   inputs_embeds_projector	post_initr   s      r:   r@   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               }|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   rr   )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'   )r4   compileris_compilingloggerwarning_once
ValueErrorr   get_seq_lengthrW   rr   arangeclampr  r  warningr  r   r^   r   r  r  r  r  r   )rF   r  r  r   r   r'   r  r   r   r   past_seen_tokensinputs_seq_lengthrr   codebook_idxsoffsetinput_ids_are_first_codebookr   r(   r   decoder_layers                       r:   rU   zCsmDepthDecoderModel.forward  s>   & #ENN,G,G,IM  L-t";<Z[[0*nO!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
 	
r9   )NNNNNNNN)r0   r1   r2   r    r6   r@   r   r   r4   r   r   r5   r   r
   r   r   r   r   r7   r   rU   rZ   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
r9   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?   r@   r   rA   rB   r4   emptyrD   )rF   rG   r   r  rI   s       r:   r@   zCsmCodebooksHead.__init__  s?    *ll5;;t/A/AA/E{T^#_`r9   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   rx   )
rW   rD   r4   r+  r   rA   r   linearTstack)rF   r(   r   
seq_lengthcodebook_weightr0  codebook_idxs          r:   rU   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
r9   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                   8    e Zd ZdZdZdZ fdZd Z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?   r@   r
  r   r  r   rG   r   codebooks_headr  r   s     r:   r@   z#CsmDepthDecoderForCausalLM.__init__  sY     )&1
 ++.v/A/A6CWCWY_YjYjk 	r9   c                     || _         y r   r   )rF   decoders     r:   set_decoderz&CsmDepthDecoderForCausalLM.set_decoder  s	    
r9   c                     | j                   S r   rD  rX   s    r:   get_decoderz&CsmDepthDecoderForCausalLM.get_decoder  s    zzr9   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&   rI  r  shift_labels)r%   r&   r'   r(   r)   r8   )r   rh   r   slicerB  r   loss_functionr^   r  r   r'   r(   r)   )rF   r  r  r   r   r'   r  rI  r   r   rJ  r   outputsr(   slice_indicesr&   r%   rL  s                     r:   rU   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!//))
 	
r9   c                     t        	|   |||||fi |}|d   d   dk(  }|s|j                  d       |j                  d       |S )Nr   r   r  r   )r?   prepare_inputs_for_generationpop)
rF   r  r'   r   r  r   r   model_inputsis_first_generation_steprI   s
            r:   rR  z8CsmDepthDecoderForCausalLM.prepare_inputs_for_generationf  sg     w<~
Y_
 $00@#A!#D#I '9: 	(r9   )
NNNNNNNNNr   NNNN)r0   r1   r2   _tied_weights_keys_tp_plan_pp_planr@   rF  rH  r   r   r4   r   r   r5   r   r   r
   listr   r   r   r   r7   r   rU   rR  rZ   r[   s   @r:   r@  r@    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 r9   r@  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_offsetsFre   )r?   r@   rA   r  r   r  rG   embed_audio_tokensrp   r4   r+  r   s     r:   r@   z#CsmBackboneModelEmbeddings.__init__~  sn    "$,,0D0DvGXGX0X[a[m[m"n"ELL1E1E$FIZIZ$Zgl 	 	
r9   c                 f    | j                  || j                  z         }|j                  d      }|S )Nr   rx   )r_  r^  sum)rF   r  r"  s      r:   rU   z"CsmBackboneModelEmbeddings.forward  s6    ..y4;T;T/TU#''A'.r9   r   r[   s   @r:   r\  r\  }  s    
r9   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?   r@   r  r  r  r\  r  rA   r  r   r  r   r  r=   rG   r   r  r]   r  r  r  r   s      r:   r@   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           
      *   |du |duz  rt        d      || j                  |      }|r|
t               }|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*  r4   r+  rW   rr   r   r   r^   r  r  r  r  r   )rF   r  r   r   r'   r  r   r   r   r.  r   r(   r   r3  s                 r:   rU   zCsmBackboneModel.forward  sT   2 -t";<YZZ *.*;*;I*FM0*nO!CRC^==?de+0<< "2]5H5H5K"KTaThTh,N )33A6L(;;&))+%
 &"oom\J![[)H4;;+H+HI 		M)*).-$7 M		 		-0&++
 	
r9   )NNNNNNN)r0   r1   r2   r@   r   r   r   r4   r   r   r
   r5   r   r   r   r   rU   rZ   r[   s   @r:   rc  rc    s      151537+/5959$(D
E,,-D
 !.D
 u//0	D

 "%D
   1 12D
 !!1!12D
 D>D
 +,D
 
!D
  D
r9   rc  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?   r@   r  rA   r   rG   lm_headr  text_vocab_sizeembed_text_tokensrc  _from_configbackbone_modelr@  depth_decoder_configdepth_decoderr   from_configcodec_configcodec_modelr  r   s     r:   r@   z$CsmForConditionalGeneration.__init__  s      ++yy!3!3V5F5FUS!#f.D.DfFXFX!Y.;;FC7DDVE`E`a$001D1DEr9   c                 .    | j                   j                  S r   rm  r  rX   s    r:   get_input_embeddingsz0CsmForConditionalGeneration.get_input_embeddings  s    ""///r9   c                 &    || j                   _        y r   rt  )rF   r   s     r:   set_input_embeddingsz0CsmForConditionalGeneration.set_input_embeddings  s    +0(r9   c                     | j                   j                  rO| j                  | j                  j                  j
                  | j                  j                  j                         y y r   )r^   tie_codebooks_embeddings_tie_or_clone_weightsrm  r  r_  ro  r   rX   s    r:   _tie_weightsz(CsmForConditionalGeneration._tie_weights   sL    ;;//&&##00CC""((55 0r9   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)rj   r?   from_pretrainedlenvarsgeneration_configitems
startswithro  r   delattr)clsargsr   r   loading_infoprefix
prefix_lenattrr   depth_decoder_attrsrI   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)ro  r  to_diff_dictrS  r  setattrr?   save_pretrained)rF   r  r   r  r  r  r   rI   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0r9   r  input_valuesinput_values_cutoffsrI  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  rK   r   .c              3   :   K   | ]  }|j                   d      yw)r   N)rW   ).0els     r:   	<genexpr>zQCsmForConditionalGeneration._merge_input_ids_with_input_values.<locals>.<genexpr>\  s     &Orrxx{&Os   )rr   rM   iTas_tuple)r  rI  )$rk  rA   r   paddiffr4   r+  maxrr   r{   r  r   r   zipr   rW   rr  encodeaudio_codesr~   appendr;  get_audio_codes_maskr^   audio_token_idrm  r  rC   r   longcodebook_eos_token_idsqueezeaudio_eos_token_idrepeatra  nonzero)rF   r  r  r  rI  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  rI  )r  r  r  rI  )r  rI  r  r8   )r?   rR  ndimrj   r  r   )
rF   r  r'   r   r  r   r   rT  merged_inputsrI   s
            r:   rR  z9CsmForConditionalGeneration.prepare_inputs_for_generation~  s     w< 
+)')
 
  Y^^q%8\=M=Mo=^=f CC##ZZ7%+ZZ0F%Gzz(+	 D M "/"@MZbLcrvw r9   r   r   rJ  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 infered 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  rI  )r  r   r   r'   r  r   r   r   )r&   rI  r  r   r  rK   rx   .r  )r   Tr  )r  r  r   return_dictrI  )r%   r/   r*   r&   r'   r(   r)   r+   r,   r-   r.   r8   )r  r  rm  rh   r   rM  ri  rN  r^   r  allr   rA   r   r  r  ro  r%   r$   r'   r(   r)   r&   )rF   r  r  r   r  r   r'   r  rI  r   r   rJ  r   r  backbone_outputsbackbone_hidden_statesrP  backbone_logitsr%   r/   r*   depth_decoder_outputsbackbone_labels
train_maskdepth_decoder_input_ids
train_idxsbackbone_last_hidden_statesdepth_decoder_labelss                               r:   rU   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
 	
r9   rV  )NNNNNNNNNNr   )r0   r1   r2   rW  r@   ru  rw  r{  classmethodr  r  r   r4   r   r  r   r
   r5   rR  r   r   r   rZ  r   r   r   r   r7   r$   rU   rZ   r[   s   @r:   rg  rg    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''	([
  [
r9   rg  )r   rc  r
  r@  rg  r6  )r   )Idataclassesr   typingr   r   r   r4   torch.nnrA   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   autor   configuration_csmr   r    generation_csmr!   
get_loggerr0   r'  r$   Moduler=   r]   r   r   r   r   r   r   rz   r   r   r   r   r
  r   r@  r\  rc  rg  __all__r8   r9   r:   <module>r     s  , " , ,   9 ! . ) 7 / 9 O K F & _ _  ? . 
		H	% 
)6 )6 )6X Y'J J (J(< <DRYY  (6	UU\\ 	U# 	U%,, 	U& %II%<<% 
% <<	%
 U\\*% % % '(%4C)299 C)L*0 *Z 
 [ [ [4 g
- g
 g
Tryy . l!3_ ll^  V
) V
 V
r 
P
"46H P

P
f
r9   