a h+ @sdZddlZddlmZmZmZmZddlZddlZddlm Z ddl m Z m Z m Z ddlmZddlmZdd lmZdd lmZdd lmZdd lmZmZmZdd lmZmZddlm Z ddl!m"Z"m#Z#ddl$m%Z%ddl&m'Z'm(Z(ddl)m*Z*e(rddl+m,Z,m-Z-ddl.m/Z/n d\Z/Z-Z,e'rBddl0m1Z1m2Z2nd\Z2Z1e3e/e-e1e2e,fZ4e#5e6Z7Gddde j8Z9ej:e;ej:dddZe>d!d"d#Z?Gd$d%d%e j8Z@Gd&d'd'e j8ZAGd(d)d)e j8ZBGd*d+d+e j8ZCGd,d-d-e j8ZDGd.d/d/e j8ZEe"Gd0d1d1eZFe"Gd2d3d3eFZGGd4d5d5eFeZHe"d6d7Gd8d9d9eFZIgd:ZJdS)cs&ttt||_||_dS)z; ZambaRMSNorm is equivalent to T5LayerNorm N)super__init__r Parametertorchonesweightvariance_epsilon)self hidden_sizeeps __class__d/var/www/html/assistant/venv/lib/python3.9/site-packages/transformers/models/zamba/modeling_zamba.pyr%As zZambaRMSNorm.__init__cCsJ|j}|tj}|djddd}|t||j}|j||S)NT)Zkeepdim) dtypetor'float32powmeanZrsqrtr*r))r+ hidden_statesZ input_dtypeZvariancer0r0r1forwardIs  zZambaRMSNorm.forwardcCst|jjd|jS)Nz, eps=)tupler)shaper*r+r0r0r1 extra_reprPszZambaRMSNorm.extra_repr)r#)__name__ __module__ __qualname__r%r:r> __classcell__r0r0r.r1r"@sr")r9n_repreturncCs^|j\}}}}|dkr|S|dddddddddf|||||}||||||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) rN)r<expandreshape)r9rCbatchnum_key_value_headsslenhead_dimr0r0r1 repeat_kvUs 0rKc@seZdZdZdZejdfddZddZe e ej ej fdd d Z dej ej e e eeefe ej ej fd d d ZejdddZde e e dddZdS)ZambaHybridDynamicCachea A dynamic cache that can handle both the attention cache (which has a seq_len dimension) and the mamba cache (which has a constant shape regardless of seq_len). This cache has two sets of lists of tensors: `key_cache` and `value_cache` for attention cache and `conv_states` and `ssm_states` for mamba cache. Each of these lists has `num_layers` tensors. The expected shape for each tensor For attention layers, `key_cache` and `value_cache` have a shape of `(batch_size, num_heads, seq_len, head_dim)`, while `conv_states` and `ssm_states` have a shape of `(batch_size, 0)` (empty tensors). For mamba layers, `key_cache` and `value_cache` have a shape of `(batch_size, 0)` (empty tensors), while `conv_states` represents the convolution state and has a shape of `(batch_size, d_inner, d_conv)`, and `ssm_states` represents the ssm state and has a shape of `(batch_size, d_inner, d_state)`. FNc s"||_d|_|j|_d|_|j|j|_|j|_|j |_ |j |_ g|_ g|_ g|_i|_i|_i|_t|jD]v}|j tj|j|j |dg7_ |j |j|j |jf}|j tj||dg7_ |j|dkrn|j|qnfddt|jD|_fddt|jD|_dS)NFdevicer4hybridcs g|]}tjggdqSrNr'Ztensor.0_ batch_sizerNr0r1 z4ZambaHybridDynamicCache.__init__..cs g|]}tjggdqSrPrRrSrVr0r1rXrY)r4is_compileablelayers_block_typehas_previous_state mamba_expandr,intermediate_size mamba_d_statessm_state_size mamba_d_convconv_kernel_size n_mamba_heads conv_states ssm_statestransformer_layersZ_modules _parameters_buffersrangenum_hidden_layersr'zerosappend key_cache value_cache)r+configrWr4rNiZ cache_shaper0rVr1r%qs8 z ZambaHybridDynamicCache.__init__cCs t|jSN)lenrmr=r0r0r1__len__szZambaHybridDynamicCache.__len__) layer_idxrDcCs|j||j|fSrq)rmrnr+rtr0r0r1 __getitem__sz#ZambaHybridDynamicCache.__getitem__) key_states value_statesrt cache_kwargsrDcCsz|j|jddkr*||j|<||j|<ntj||j|jddf} |j|j| t|| |j j|jd}|dur|t|dks|||d}|d|j |j|dd}|jdddddddf|dd} tj| |j|j|jgdd\} }}|j dddf| dd}t!|j"# }|j$dur*|j$#nd}tj%|d|f|j&|j'd}|rt(|j D]}t)|j*|jdd|f||d df||d df||||dddf||dddf|j+|| |d df||d d d}tj,||fdd}qXntj%|d|j|jf|j&|j'd}t(|j D]}t-||||||||dd||dd|j+|#| |||d d d \}}tj,||fdd}tj,||dfdd}q|dur|dur|j*|j||.|dd}|S) Nrr2r3rzr)rrrM.T)Z dt_softplus)Zdelta_softplusZreturn_last_state)/r<r\rrrchunksqueezerrFrcrr)sizer!rdrtrr unsqueezer'allrrpadrbcopy_r rrsplitrr`rexprfloatremptyrNr4rirrerr|rr)r+r9rrrWseq_lenrUZuse_precomputed_statesprojected_statesgateZ conv_weightsrdssm_parameters time_stepBCdiscrete_time_steprZtime_proj_bias scan_outputsnZ scan_outputs_ ssm_stateZ ssm_state_contextualized_statesr0r0r1cuda_kernels_forwardls  $   *        z$ZambaMambaMixer.cuda_kernels_forward)rc Cs|j\}}}|j}||dd}||dd|jddd\} } | d} | d} | ||j d|dd} t |t } | rb|j |j jd|krb|jr|j |j } n |j |j } | | j} |jr|dkr|j|j jd|kr|j|j } tj| ddd} | dddddf| dddddf<| |j|j <tj| |jjdddddfdd} |jr| |jj7} || |d} n|durt|dks| |dd| jd dfd} tj | |j!| jddf} | |j|j <||| dd|f} |durt|dks| |dd| jd dfd} ntj"||j |j#|j$f| j|d} |durt|dks| |d} ||| dd|f} |durt|dks| |d} | d|j |j#|dd} |j%dddddddf| dd }tj&||j'|j$|j$gdd\}}}|j(dddf|dd |j)ddddddf}tj*|}t+|j,- }t+|ddddddddf|dddddddddf}|dddddddddf|dddddddddf-}|| dddddddddf-}g}t.|D]}|dddddd|ddfdd| |dddddd|ddfdd} t/| dd||dddd|ddfd}|0|dddddddfqptj1|dd}|| |j2ddddddf}||| }| rz| |j |j <|3|dd|d|dd}|S) Nrr2r3rzr)Zshiftsdims.rMr)4r<r4rrrrrrrFrc isinstancerLrertrcloner5rNr\rdr'Zrollsumrr)rrrrrrrrrbrkrr`rrrrrZsoftplusrrrrirrlstackrr)r+Z input_statesrrrWrrUr4rr9r use_cacherZ conv_staterrrrrrZ discrete_AZ discrete_BZdeltaB_urrpZ scan_outputrr0r0r1 slow_forwards      ( ( & (*   FH* X8&" zZambaMambaMixer.slow_forwardcCs@|jr0trd|jjjvr td|j|||dS|j|||dS)NcudazFast Mamba kernels are not available. Make sure to they are installed and that the mamba module is on a CUDA device. lease run 'pip install causal-conv1d>=1.2.0' and 'pip install mamba-ssm', or set use_mamba_kernels=False in the model's config.)r)rrrrNtype ValueErrorrr)r+r9rrr0r0r1r:*szZambaMambaMixer.forward)NN)NN)NN) r?r@rArrr%r'rrLrrr:rBr0r0r.r1r"s > a]rcs$eZdZfddZddZZS)ZambaMLPcsrt||_|j|_|j|_tj|j|jdd|_tj|j|jdd|_tj|j|jdd|_ t |j |_ dSNFr) r$r%ror,r^rr gate_projup_proj down_projr Z hidden_actact_fnr+ror.r0r1r%8s zZambaMLP.__init__cCs$||||||}|Srq)rrrr)r+xrr0r0r1r:Bs zZambaMLP.forward)r?r@rAr%r:rBr0r0r.r1r7s rcseZdZd eeedfdd Zedddddej ej eeej ee ee ee e e eejeeejejffd d d ZZS)ZambaAttentionDecoderLayerNrcsHtt|||_t||_t|j|jd|_ t|j |jd|_ dS)Nr-) r$r%r self_attnr feed_forwardr"r rms_norm_epsinput_layernormr,pre_ff_layernormrr.r0r1r%Hs    z#ZambaAttentionDecoderLayer.__init__rrrrF) r9original_hidden_statesrtrroutput_attentionsrrrDc Ksjtj||gdd}||}|jf||||||d|\}} ||}||}|f} |rf| | f7} | S)a Args: hidden_states (`torch.FloatTensor`): output of previous Mamba layer of shape `(batch, seq_len, embed_dim)` original_hidden_states (`torch.FloatTensor`): word embedding output of shape `(batch, seq_len, embed_dim)`. This is concatenated with `hidden_states` (which is the output of the previous (mamba) layer). The concatenated tensor is then used as input of the pre-attention RMSNorm (see fig. 2 in https://huggingface.co/papers/2405.16712). layer_idx (`int`): layer_idx in the forward pass. Used to distinguish Zamba's tied transformer layers. attention_mask (`torch.FloatTensor`, *optional*): attention mask of size `(batch, sequence_length)` where padding elements are indicated by 0. past_key_values (`ZambaHybridDynamicCache`, *optional*): cached past key and value projection states output_attentions (`bool`, *optional*): Whether or not to return the attentions tensors of all attention layers. See `attentions` under returned tensors for more detail. use_cache (`bool`, *optional*): If set to `True`, `past_key_values` key value states are returned and can be used to speed up decoding (see `past_key_values`). cache_position (`torch.LongTensor` of shape `(sequence_length)`, *optional*): Indices depicting the position of the input sequence tokens in the sequence. r3rz)r9rtrrrr)r'Z concatenaterrrr) r+r9rrtrrrrrself_attn_weightsoutputsr0r0r1r:Ps$     z"ZambaAttentionDecoderLayer.forward)N)NNFF)r?r@rArrrr%rr'rrLboolrrr; FloatTensorr:rBr0r0r.r1rGs" rcseZdZeedfdd Zeddddd eje eje ee eje eje e e e e e e ej e eje eje e ejejffd d d ZZS)ZambaMambaDecoderLayerrcs4tt||d|_t|j|jd|_||_dS)Nrr) r$r%rmambar"r,rrrtrr.r0r1r%s zZambaMambaDecoderLayer.__init__rrrrNF) r9rrtrrrrrcache_positiontransformer_hidden_statesrDc Ksd|} | dur|| n|}||}|j|||d}d} | |}|f}|rR|| f7}|r`||f7}|S)a Args: hidden_states (`torch.FloatTensor`): input to the layer of shape `(batch, seq_len, embed_dim)` attention_mask (`torch.FloatTensor`, *optional*): attention mask of size `(batch, sequence_length)` where padding elements are indicated by 0. past_key_values (`ZambaHybridDynamicCache`, *optional*): cached past key and value projection states output_attentions (`bool`, *optional*): Whether or not to return the attentions tensors of all attention layers. See `attentions` under returned tensors for more detail. use_cache (`bool`, *optional*): If set to `True`, `past_key_values` key value states are returned and can be used to speed up decoding (see `past_key_values`). cache_position (`torch.LongTensor` of shape `(sequence_length)`, *optional*): Indices depicting the position of the input sequence tokens in the sequence. N)r9rr)rr)r+r9rrtrrrrrrrrZresidualrrr0r0r1r:s"   zZambaMambaDecoderLayer.forward) NNNNNFFNN)r?r@rArrr%rr'rrrLrrr;rr:rBr0r0r.r1rs0 rcseZdZeejedfdd Zeddddd e j e e j e e e e j e e j e e e ee ee e jee je ee je jffd d d ZZS)ZambaHybridLayer) shared_transflinearrcs t||_||_||_dSrq)r$r%r r  mamba_decoder)r+r r rr.r0r1r%s zZambaHybridLayer.__init__rrrrNF) r9rrtrrrrrrrDc Csp|j|||||||| d} | d} |r.| d} || } |j|| ||||| d} |rl| d| f| dd} | S)a Args: hidden_states (`torch.FloatTensor`): input to the layer of shape `(batch, seq_len, embed_dim)` original_hidden_states (`torch.FloatTensor`): word embedding output that will be concatenated with hidden activations to form the input of the shared transformer layer. layer_idx (`int`): layer number. attention_mask (`torch.FloatTensor`, *optional*): attention mask of size `(batch, sequence_length)` where padding elements are indicated by 0. past_key_values (`ZambaHybridDynamicCache`, *optional*): cached past key and value projection states output_attentions (`bool`, *optional*): Whether or not to return the attentions tensors of all attention layers. See `attentions` under returned tensors for more detail. use_cache (`bool`, *optional*): If set to `True`, `past_key_values` key value states are returned and can be used to speed up decoding (see `past_key_values`). cache_position (`torch.LongTensor` of shape `(sequence_length)`, *optional*): Indices depicting the position of the input sequence tokens in the sequence. )rrtrrrrrrr)rrrrrrr2N)r r r ) r+r9rrtrrrrrr layer_outputsrrr0r0r1r:s4    zZambaHybridLayer.forward)NNNNNFFN)r?r@rArrrrr%rr'rrrrLrrr;rr:rBr0r0r.r1r s, r c@s>eZdZUeed<dZdZddgZdZdZ dZ dZ dd Z d S) ZambaPreTrainedModelromodelTrrrFcCs|jj}t|tjtjfrF|jjjd|d|j durB|j j nt|tj r|jjjd|d|j dur|jj|j  nJt|t r|jjdn.t|tr|jjjd|d|jjd}tj|j| ||jj|jj|jj}tt|jj|t|jjt|jjt|jjj|jj d}|tt!|  }|j"j#|tj$d|j%dtj&ddddf}|'|j(d)}|j*j#t|+|j|j,d|j-jddS) Nr)r8stdg?r)minrrr3).roZinitializer_rangerrrrr)dataZnormal_rZzero_ Embedding padding_idxr"Zfill_rrrinitZuniform_rr]r,rcr'rZrandmathrZ time_step_maxZ time_step_minclampZtime_step_floorexpm1rrrr`r6rEr^rrrFrr)r+rrZ dt_init_stdrdtZinv_dtrr0r0r1 _init_weights!s>       $"z"ZambaPreTrainedModel._init_weightsN) r?r@rAr__annotations__Zbase_model_prefixZsupports_gradient_checkpointingZ_no_split_modulesZ_skip_keys_device_placementZ_supports_flash_attnZ_supports_sdpaZ _is_statefulrr0r0r0r1rs rcseZdZdZedfdd Zed eej eej eej ee eej ee ee ee ee eej eeefd ddZd d ZZS) ZambaModelz Transformer decoder consisting of *config.num_hidden_layers* layers. Each layer is a [`ZambaDecoderLayer`] Args: config: ZambaConfig rc st||j|_|j|_t|j|j|j|_t |}g}g}|j |_ t |j D]d}|j |dkrz| t||dqT|j |dkrT| tj|jj|jjdd| t||dqTt|}t|}g}g|_t|j D]n\}}|dkr>d|dgd} g|jfd d | D|_| t|t|t|q| t|qt||_|j|_t|j|jd |_d|_|dS) Nr)rtrOFrzlayers..) z%shared_transf.self_attn.q_proj.weightz%shared_transf.self_attn.k_proj.weightz%shared_transf.self_attn.v_proj.weightz%shared_transf.self_attn.o_proj.weightz+shared_transf.feed_forward.gate_proj.weightz)shared_transf.feed_forward.up_proj.weightz+shared_transf.feed_forward.down_proj.weightz$shared_transf.input_layernorm.weightz%shared_transf.pre_ff_layernorm.weightcsg|] }|qSr0r0)rTrZ prefix_namer0r1rXmrYz'ZambaModel.__init__..r)r$r% pad_token_idr vocab_sizerrr, embed_tokensrr[rirjrlrrroiter_tied_weights_keys enumerater nextZ ModuleListlayersrr"rfinal_layernormgradient_checkpointing post_init) r+roblockZ mamba_layersZ linear_layersrpr&Zlayer_idZ layer_typeZ tied_keysr.rr1r%Ks<     zZambaModel.__init__N) input_idsr position_idsr inputs_embedsrroutput_hidden_states return_dictrrDc  Cs |dur |n|jj}|dur |n|jj}|dur4|n|jj}| durH| n|jj} |du|duArhtd|jr|jr|rt dd}|dur| |}|} t |} |r|durt d| durt j | jd| jd} |dur| d}|||| } |rdnd}|rdnd}t|jD]\}}|r8|| f7}|jrh|jrh||j| | ||| |||| }n|| | ||| |||| d }|d} |r |ddur ||df7}q || } |r|| f7}|r|jsd |_t| |r|nd||d }| r|S|S) NzaYou cannot specify both input_ids and inputs_embeds at the same time, and must specify either onezX`use_cache=True` is incompatible with gradient checkpointing. Setting `use_cache=False`.Fz{Zamba requires an initialized `ZambaHybridDynamicCache` to return a cache. None was provided, so no cache will be returned.rrQrr0)rrtrrrrrrT)Zlast_hidden_staterr9 attentions)rorr.ruse_return_dictrr(rrrr!r'rrr<rNr_update_causal_maskr$r&Z_gradient_checkpointing_func__call__r'r\rZto_tuple)r+r+rr,rr-rrr.r/rr9rrZall_hidden_statesZall_self_attnsrtlayerr outputr0r0r1r:zs          zZambaModel.forwardc Cs|jjdkr$|dur d|vr |SdS|j|j}}t|j}|jd}|dd}tj||f|||d} |dkrtj | dd} | tj ||d| ddk9} | ddddddf |jdddd} |durJ| } |d krJ|jd} | d d| fd|ddddddfd} | d d| f| || d d| f<|jjd kr||dur||jjd vr|t| |} | S) NZflash_attention_2rrr3)Z fill_valuer4rN)ZdiagonalrQrr2.Zsdpa)rZxpuZnpu)rorr4rNr'Zfinforr<fullZtriurrFrErr{eqZ masked_fillrrZ_unmask_unattended) r+rZ input_tensorrr4rNZ min_dtypeZsequence_lengthZ target_lengthrZ mask_lengthZ padding_maskr0r0r1r2s6    *  4$   zZambaModel._update_causal_mask) NNNNNNNNNN)r?r@rArrr%rrr'rrrLrrrr;rr:r2rBr0r0r.r1rBs6/ nrcseZdZedfdd Zed eejeej eejee eej eejee ee ee ee eeje eej fe eefd ddZd d d ZZS)ZambaForCausalLMrcsPt|t||_dg|jj|_|j|_tj|j|jdd|_ | dS)Nzlm_head.weightFr) r$r%rrr#r rrr,lm_headr)rr.r0r1r%s   zZambaForCausalLM.__init__Nr) r+rr,rr-labelsrrr.r/rlogits_to_keeprDc  Ks|dur |n|jj}| dur | n|jj} | dur4| n|jj} |j|||||||| | | d }|d}t| trxt| dn| }||dd|ddf}d}|dur|j |||j fi| }| s|f|dd}|dur|f|S|St |||j |j |jdS)ah 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]`. Example: ```python >>> from transformers import AutoTokenizer, ZambaForCausalLM >>> model = ZambaForCausalLM.from_pretrained("Zyphra/Zamba-7B-v1") >>> tokenizer = AutoTokenizer.from_pretrained("Zyphra/Zamba-7B-v1") >>> prompt = "Hey, are you conscious? Can you talk to me?" >>> inputs = tokenizer(prompt, return_tensors="pt") >>> # Generate >>> generate_ids = model.generate(inputs.input_ids, max_length=30) >>> tokenizer.batch_decode(generate_ids, skip_special_tokens=True, clean_up_tokenization_spaces=False)[0] "Hey, are you conscious? Can you talk to me?\nI'm not conscious, but I can talk to you." ```N) r+rr,rr-rrr.rr/rrlosslogitsrr9r0)rorr.r1rrrslicer9Z loss_functionr rrr9r0)r+r+rr,rr-r:rrr.r/rr;rrr9Z slice_indicesr>r=r5r0r0r1r:s@( zZambaForCausalLM.forwardTc Ks|du} | sj|dus&|d|jdkrD|dd|jd df}q|jd|jdkr|dd|f}nt|j|jd|j|jd}|dur|dur|dd}||dkd| s|dd|jd df}|dur| rd|i} n d|i} | |||||jj |d| S)Nr3rr)r4rNr-r+)r,rrrr;r) r<rLror4rNlongZcumsumZ masked_fill_rr}Znum_logits_to_keep) r+r+rrr-rr,rrZ empty_past_kvZ model_inputsr0r0r1prepare_inputs_for_generationks<     z.ZambaForCausalLM.prepare_inputs_for_generation) NNNNNNNNNNNr)NNNNNT)r?r@rArr%rrr'rrrLrrrrr;rr:rArBr0r0r.r1r8sH   Tr8a The Zamba Model with a sequence classification head on top (linear layer). [`ZambaForSequenceClassification`] uses the last token in order to do the classification, as other causal models (e.g. GPT-2) do. Since it does classification on the last token, it requires to know the position of the last token. If a `pad_token_id` is defined in the configuration, it finds the last token that is not a padding token in each row. If no `pad_token_id` is defined, it simply takes the last value in each row of the batch. Since it cannot guess the padding tokens when `inputs_embeds` are passed instead of `input_ids`, it does the same (take the last value in each row of the batch). )Z custom_introcseZdZfddZedeejeejeejee e e ej feej eejee ee ee ee e eefd ddZZS)ZambaForSequenceClassificationcsJt||j|_t||_|jj|_tj|j|jdd|_ | dSr) r$r% num_labelsrrr#rrr,scorer)rr.r0r1r%s    z'ZambaForSequenceClassification.__init__N) r+rr,rr-r:rrr.r/rDc  CsV| dur | n|jj} |j|||||||| | d } | d} || } |durV|jd}n |jd}|jjdur||dkr|td|jjdurd}nb|dur||jjk| jt j }t j |jd| jt j d}|| d}nd}t |jjd| t j || jd |f}d}|dur|| j}|jjdur|jdkrFd |j_n:|jdkrx|jt jksn|jt jkrxd |j_nd |j_|jjd krt}|jdkr|||}n |||}nN|jjd krt}||d|j|d}n|jjd krt}|||}| s>|f| dd}|dur:|f|S|St||| j| j| jd S)a labels (`torch.LongTensor` of shape `(batch_size,)`, *optional*): Labels for computing the sequence classification/regression loss. Indices should be in `[0, ..., config.num_labels - 1]`. If `config.num_labels == 1` a regression loss is computed (Mean-Square loss), If `config.num_labels > 1` a classification loss is computed (Cross-Entropy). N)rr,rr-rrr.r/rrz=Cannot handle batch sizes > 1 if no padding token is defined.r3rMz will not detect padding tokens in `inputs_embeds`. Results may be unexpected if using padding tokens in conjunction with `inputs_embeds.`rQZ regressionZsingle_label_classificationZmulti_label_classificationr<)ror1rrDr<rrr5rNr'Zint32rZargmaxrrr/r?Z problem_typerCr4r@rr rrrrrrr9r0)r+r+rr,rr-r:rrr.r/Ztransformer_outputsr9r>rWZlast_non_pad_tokenZ non_pad_maskZ token_indicesZ pooled_logitsr=Zloss_fctr5r0r0r1r:sx          (    z&ZambaForSequenceClassification.forward) NNNNNNNNNN)r?r@rAr%rrr'rrrr listrrr;rr:rBr0r0r.r1rBs2  rB)r8rBrr)r)Krrtypingrrrrr'Ztorch.utils.checkpointrZtorch.nnrrr Z activationsr Z cache_utilsr Z generationr Zmodeling_attn_mask_utilsrZmodeling_flash_attention_utilsrZmodeling_outputsrrrZmodeling_utilsrrZprocessing_utilsrutilsrrZutils.deprecationrZutils.import_utilsrrZconfiguration_zambarZ&mamba_ssm.ops.selective_scan_interfacerrZ+mamba_ssm.ops.triton.selective_state_updaterZ causal_conv1dr r!rrZ get_loggerr?rModuler"rrrKrLrrrrrrrr rrr8rB__all__r0r0r0r1s|             g G@EI,Lj