+ jA*Rt^RIt^RIHt^RIHt^RIt^RIHt^RI H t ^RI H t ^RI Ht^RIHt^RIHt^R IHt^R IHtHtHt^R IHtHtHtHt^R IH t ]PB!]"4t#!R R]PH4t%!RR]PH4t&!RR]PH4t'!RR]PH4t(!RR]PH4t)!RR]PH4t*RhRRllt+!RR]PH4t,!RR]PH4t-!RR ]PH4t.!R!R"]PH4t/!R#R$]PH4t0!R%R&]PH4t1!R'R(]PH4t2]!R)R*] 44t3!R+R,]PH4t4RiR-R.llt5RjR/R0llt6!R1R2]PH4t7!R3R4]PH4t8!R5R6]PH4t9!R7R8]PH4t:!R9R:]PH4t;]!R;R<7]!R=R>] 444t<!R?R@]34t=]!RAR<7]!RBRC] 444t>]!RDR<7!RERF]344t?]!RGR<7]!RHRI] 444t@]!RJR<7!RKRL]344tA]!RMR<7]!RNRO] 444tB]!RPR<7]!RQRR] 444tC]!RPR<7]!RSRT] 444tDRURVltERkRWRXlltF!RYRZ]34tG]!R[R<7]!R\R]] 444tH!R^R_]34tI]!R`R<7]!RaRb] 444tJ!RcRd]PH4tK]!ReR<7!RfRg]344tL.RlOtMR#)mzPyTorch PatchTSMixer model.N)Callable) dataclass)PreTrainedModel) ModelOutput)initialization)FlashAttentionKwargs)ALL_ATTENTION_FUNCTIONS)Unpack)NegativeBinomialOutput NormalOutputStudentTOutput)TransformersKwargsauto_docstringcan_return_tupleloggingPatchTSMixerConfigcHaa]tRt^&toRtV3RlV3RlltRtRtVtV;t #)PatchTSMixerGatedAttentionz Module that applies gated attention to input data. Args: in_size (`int`): The input size. out_size (`int`): The output size. c&<V^8dQhRS[RS[/#)in_sizeout_sizeint)format __classdict__s"w/home/luca/screen-checking/.venv/lib/python3.14/site-packages/transformers/models/patchtsmixer/modeling_patchtsmixer.py __annotate__'PatchTSMixerGatedAttention.__annotate__/s///s/c<\SV`4\P!W4Vn\P !RR7VnR#)dimN)super__init__nnLinear attn_layerSoftmax attn_softmax)selfrr __class__s&&&rr'#PatchTSMixerGatedAttention.__init__/s/ ))G6JJ2.r cVVPVPV44pW,pV#N)r,r*)r-inputs attn_weights&& rforward"PatchTSMixerGatedAttention.forward4s(''(?@ % r )r*r, __name__ __module__ __qualname____firstlineno____doc__r'r4__static_attributes____classdictcell__ __classcell__r.rs@@rrr&s// r rcTaa]tRt^;toRtV3RlV3RlltV3RlRltRtVtV;t #)PatchTSMixerBatchNormzH Compute batch normalization over the sequence length (time) dimension. c <V^8dQhRS[/#rconfigr)rrs"rr"PatchTSMixerBatchNorm.__annotate__@sMM1Mr c<\SV`4\P!VPVP R7VnR#)epsN)r&r'r( BatchNorm1dd_modelnorm_eps batchnormr-rDr.s&&rr'PatchTSMixerBatchNorm.__init__@s( FOOLr c4<V^8dQhRS[P/#rr2torchTensor)rrs"rrrEDs & &ell &r c lVP^^4pVPV4pVP^^4#)z Parameters: inputs (`torch.Tensor` of shape `(batch_size, sequence_length, d_model)`): input for Batch norm calculation Returns: `torch.Tensor` of shape `(batch_size, sequence_length, d_model)` ) transposerL)r-r2outputs&& rr4PatchTSMixerBatchNorm.forwardDs7!!!Q''1%%r )rLr6r?s@@rrArA;s%MM & & &r rAcpaa]tRt^QtoRtV3RlV3Rllt]V3RlRl4tV3RlRltRt Vt V;t #) PatchTSMixerPositionalEncodingz Class for positional encoding c <V^8dQhRS[/#rCr)rrs"rr+PatchTSMixerPositionalEncoding.__annotate__Vs^^1^r c<\SV`4VP'dVPV4VnR#\ P !\P!VPVP44VnR#r1) r&r'use_positional_encoding_init_pe position_encr( ParameterrRzeros num_patchesrJrMs&&rr''PatchTSMixerPositionalEncoding.__init__VsQ   ) ) ) $ f 5D  " U[[9K9KV^^-\ ]D r c:<V^8dQhRS[RS[P/#)rrDreturn)rr(r`)rrs"rrr[_s + r cVPR8XdD\P!\P!VP VP 4RR7pV#VPR8XEdJ\P!VP VP 4p\P!^VP 4P^4p\P!\P!^VP ^4\P!R4VP , ),4p\P!W#,4VR&\P!W#,4VR&WP4, pWP!4^ ,, p\P!VRR7pV#\#VP R24h) randomT requires_gradsincosg@FzN is not a valid positional encoder. Available types are 'random' and 'sincos'.)NNN:Nr)rk:r"Nr)positional_encoding_typer(r`rRrandnrbrJraarange unsqueezeexpmathlogsincosmeanstd ValueError)rDr_positiondiv_terms& rr^'PatchTSMixerPositionalEncoding._init_pe^sZ  * *h 6<< F4F4F(WgklL , , 8 ;;v'9'96>>JL||Av'9'9:DDQGHyya!CQXHY\b\j\jHjFk!klH$)IIh.A$BL !$)IIh.A$BL !'*;*;*==L'+;+;+=+BCL<< EJL 2234BC r c4<V^8dQhRS[P/#r patch_inputrQ)rrs"rrr[rs5<<r c*WP,pV#r1r_)r-r~ hidden_states&& rr4&PatchTSMixerPositionalEncoding.forwardrs"%6%66 r r) r7r8r9r:r;r' staticmethodr^r4r<r=r>r?s@@rrYrYQs9^^&r rYcTaa]tRt^xtoRtV3RlV3RlltV3RlRltRtVtV;t #)PatchTSMixerNormLayerzUNormalization block Args: config (`PatchTSMixerConfig`): Configuration. c <V^8dQhRS[/#rCr)rrs"rr"PatchTSMixerNormLayer.__annotate__sJJ1Jr c <\SV`4VPVnRVPP49d\ V4VnR#\ P!VPVPR7VnR#)batchrGN) r&r'norm_mlplowerrAnormr( LayerNormrJrKrMs&&rr'PatchTSMixerNormLayer.__init__sT  foo++- --f5DI V^^IDIr c4<V^8dQhRS[P/#rPrQ)rrs"rrrsellr c RVPP49d\P!VVP^,VP^,,VP^,VP^,34pVP V4p\P!W!P4pV#VP V4pV#)z Args: inputs (`torch.Tensor` of shape `((batch_size, num_channels, num_patches, d_model))`): Input to the normalization layer. Returns: `torch.Tensor` of shape `((batch_size, num_channels, num_patches, d_model))` r)rrrRreshapeshaper)r-r2inputs_reshapeds&& rr4PatchTSMixerNormLayer.forwards dmm))+ +#mmLLOfll1o5LLOLLOO#ii8O]]?LLAF  YYv&F r )rrr6r?s@@rrrxs%JJr rcDaa]tRt^toV3RltV3RlRltRtVtV;t#)PatchTSMixerMLPcH<\SV`4WP,p\P!W4Vn\P !VP4Vn\P!WB4Vn \P !VP4Vn R#r1) r&r'expansion_factorr(r)fc1Dropoutdropoutdropout1fc2dropout2)r- in_features out_featuresrD num_hiddenr.s&&&& rr'PatchTSMixerMLP.__init__sd  #:#:: 99[5 6>>2 99Z6 6>>2 r c4<V^8dQhRS[P/#rPrQ)rrs"rrPatchTSMixerMLP.__annotate__s  ell r c VP\PPVP V444pVP V4pVP V4pV#)z Args: inputs (`torch.Tensor` of shape `((batch_size, num_channels, num_patches, d_model))`): Input to the MLP layer. Returns: `torch.Tensor` of the same shape as `inputs` )rr( functionalgelurrr)r-r2s&&rr4PatchTSMixerMLP.forwardsKr}}11$((62BCD&!v& r )rrrr r7r8r9r:r'r4r<r=r>r?s@@rrrs3   r rcTaa]tRt^toRtV3RlV3RlltV3RlRltRtVtV;t #)$PatchTSMixerChannelFeatureMixerBlockzzThis module mixes the features in the channel dimension. Args: config (`PatchTSMixerConfig`): Configuration. c <V^8dQhRS[/#rCr)rrs"rr1PatchTSMixerChannelFeatureMixerBlock.__annotate__s1r c(<\SV`4\V4VnVPVn\ VP VP VR7VnVP'd)\VP VP R7Vn R#R#rrrDrrN) r&r'rr gated_attnrnum_input_channelsmlpr gating_blockrMs&&rr'-PatchTSMixerChannelFeatureMixerBlock.__init__sy )&1  ++"1122      :11FL==((6??([L,,|3K''1-88:K  $$r c\aa]tRtRtoRtRV3RlV3RllltR V3RlRlltRtVtV;t #) PatchTSMixerAttentioniz=Multi-headed attention from 'Attention Is All You Need' papercR<V^8dQhRS[RS[RS[RS[RS[RS[RS[R,/#) r embed_dim num_headsr is_decoderbias is_causalrDN)rrboolr)rrs"rr"PatchTSMixerAttention.__annotate__s_CCCC C  C  CC#T)Cr c<\SV`4WnW nW0nW,VnWpnVP V,VP8wd\RVP RV R24hVP R,VnW@n W`n \P!WVR7Vn \P!WVR7Vn\P!WVR7Vn\P!WVR7VnR#)z;embed_dim must be divisible by num_heads (got `embed_dim`: z and `num_heads`: ).)rNr)r&r'rrrhead_dimrDrxrrrr(r)k_projv_projq_projout_proj) r-rrrrrrrDr.s &&&&&&&&rr'PatchTSMixerAttention.__init__s "" !.  MMI %$.. 8MdnnM]$YKr3 }}d* $"ii 4@ ii 4@ ii 4@  )TB r c<V^8dQhRS[PRS[PR,RS[PR,RS[R,RS[S[,RS[S[PS[PR,3,/#)r hidden_stateskey_value_statesNroutput_attentionsrre)rRrSrr rtuple)rrs"rrr0s~0)0)||0) ,,-0) t+ 0)  $; 0)-.0) u||U\\D00 10)r c VRJpVPRRp.VORNVPN5pVPV4PV4P ^^4p V'dTMTp .V PRRORNVPN5p VP V 4PV 4P ^^4p VP V 4PV 4P ^^4p \P!VPP\4pT!VV V V V3RVP'gRM VPRVPRV/VBwppVP!.VORN5!P!4pVP#V4pVV3#)z#Input shape: Batch x Time x ChannelNrrrr%)rrrviewrUrrr get_interfacerD_attn_implementationrrrrrrr)r-rrrrris_cross_attention input_shape hidden_shape query_statescurrent_stateskv_shape key_states value_statesattention_interfacerrs&&&&&, rr4PatchTSMixerAttention.forward0s.T9$))#2. 88b8$--8 {{=166|DNNqRST -?)]B^))#2.BBDMMB[[055h?II!QO {{>277AKKAqQ (?(M(M KK , ,.E) %8      % $}}}C$,, % LL % 0 %  % ! \"));;;;FFH mmK0 L((r ) rDrrrrrrrrrrr)rFTFN)NNFr6r?s@@rrrs#GCC>0)0)0)r rcHaa]tRtRtoRtV3RlV3RlltRtRtVtV;t #)PatchMixerBlockiczhThis module mixes the patch dimension. Args: config (`PatchTSMixerConfig`): Configuration. c <V^8dQhRS[/#rCr)rrs"rrPatchMixerBlock.__annotate__ks;;1;r c<\SV`4\V4VnVPVnVP Vn\ VPVPVR7VnVP 'd'\VPVPR7Vn VP'dE\VPVPVPVR7Vn\V4VnR#R#)rr)rrrrDN)r&r'rr self_attnrrrbrrrrrJself_attn_headsrself_attn_layer norm_attnrMs&&rr'PatchMixerBlock.__init__ks )&1 )) ++"**++      :6CUCU`f`r`r sD     #8 .. 00 $D 36:DN r c TpVPV4pVP'dOVPwr4rVVPW4,WV4pVP VRR7wrVPW4WV4pVP ^^4pVP V4pVP'dVPV4pVP ^^4pVP'dVPVX,4pW,p V #)zj Args: hidden_state (`torch.Tensor`): Input tensor. Returns: `torch.Tensor`: Transformed tensor. F)r) rrrrrrUrrrr) r-rr batch_sizen_varsrbrJhidden_state_reshapedx_attn_rs && rr4PatchMixerBlock.forwards yy. >>>7C7I7I 4J $0$8$89Lk$c !,,-BV[,\IF^^J MF$--a3 xx - ???,,\:L$--a3 >>>>>,*?@L% r )rrrrrrrr6r?s@@rrrcs;;4!!r rcTaa]tRtRtoRtV3RlV3RlltV3RlRltRtVtV;t #)FeatureMixerBlockizrThis module mixes the hidden feature dimension. Args: config (`PatchTSMixerConfig`): Configuration. c <V^8dQhRS[/#rCr)rrs"rrFeatureMixerBlock.__annotate__sll1lr c(<\SV`4\V4VnVPVn\ VP VP VR7VnVP'd)\VP VP R7Vn R#R#r) r&r'rrrrrJrrrrMs&&rr'FeatureMixerBlock.__init__sq )&1  ++"      :6>>\b\j\j kD  r c4<V^8dQhRS[P/#rhiddenrQ)rrs"rrr sellr c TpVPV4pVPV4pVP'dVPV4pW,pV#) Args: hidden (`torch.Tensor` of shape `(batch_size, num_patches, d_model)`): Input tensor to the layer. Returns: `torch.Tensor`: Transformed tensor. )rrrr)r-rrrs&& rr4FeatureMixerBlock.forwardsK6"&! ???&&v.F r rr6r?s@@rr r s%ll r r cTaa]tRtRtoRtV3RlV3RlltV3RlRltRtVtV;t #)PatchTSMixerLayeriz The `PatchTSMixer` layer that does all three kinds of mixing. Args: config (`PatchTSMixerConfig`): Configuration. c <V^8dQhRS[/#rCr)rrs"rrPatchTSMixerLayer.__annotate__s ] ]1 ]r c<\SV`4\VR7Vn\ VR7VnVP VnVP R8Xd\VR7VnR#R#)rD mix_channelN) r&r'r patch_mixerr  feature_mixermoderchannel_feature_mixerrMs&&rr'PatchTSMixerLayer.__init__sR *&9.f=KK ;;- ')MU[)\D & (r c4<V^8dQhRS[P/#rrQ)rrs"rrrsellr c VPR8XdVPV4pVPV4pVPV4pV#)rr)rr rr)r-rs&&rr4PatchTSMixerLayer.forwardsE 99 %//7F!!&)##F+ r )r rrrr6r?s@@rrrs% ] ]r rcXaa]tRtRtoRtV3RlV3RlltRV3RlRlltRtVtV;t #) PatchTSMixerBlockiz{The main computing framework of the `PatchTSMixer` model. Args: config (`PatchTSMixerConfig`): Configuration. c <V^8dQhRS[/#rCr)rrs"rrPatchTSMixerBlock.__annotate__scc1cr c <\SV`4VPp\P!\ V4Uu.uFp\ VR7NK up4VnR#uupirN)r&r' num_layersr( ModuleListrangermixers)r-rDr+rr.s&& rr'PatchTSMixerBlock.__init__sI && mmuU_O`$aO`!%6f%EO`$ab $asAc <V^8dQhRS[/#)routput_hidden_states)r)rrs"rrr( s##$#r c .pTpVPF&pV!V4pV'gKVPV4K( V'dWC3#VR3#)a3 Args: hidden_state (`torch.Tensor`): The input tensor. output_hidden_states (`bool`, *optional*, defaults to False.): Whether to output the hidden states as well. Returns: `torch.Tensor`: The embedding. `list`: List of all hidden states if `output_hidden_states` is set to `True`. N)r.append)r-rr1all_hidden_states embeddingmods&&& rr4PatchTSMixerBlock.forward sR ;;CII##!((3 / /d? "r )r.Fr6r?s@@rr&r&s%cc###r r&cLaa]tRtRtoRtRV3RlV3RllltRtRtVtV;t #)PatchTSMixerForPredictionHeadi%zaPrediction Head for Forecasting Args: config (`PatchTSMixerConfig`): Configuration. c <V^8dQhRS[/#rCr)rrs"rr*PatchTSMixerForPredictionHead.__annotate__-s0010r c<\SV`4VPVnVPeVPP4\P !VP 4VnVfC\P!VPVP,VP4Vn M1VPVPVP,4Vn \P!RR7VnR#)N start_dim)r&r'prediction_channel_indicessortr(r head_dropout dropout_layerr)rbrJprediction_lengthbase_forecast_blockget_parameter_projectionFlattenflatten)r-rDdistribution_outputr.s&&&rr'&PatchTSMixerForPredictionHead.__init__-s *0*K*K'  * * 6  + + 0 0 2ZZ(;(;<  &')yy&2D2Dv~~2UX^XpXp'qD $':'S'S""V^^3(D $zzB/ r c aSPV4pSPV4pSPV4p\V\4'd.\;QJd.RV4FNK 5M !RV44pMVP RR4pSP eb\V\4'd7\;QJd.V3RlV4FNK 5pV#!V3RlV44pV#VRSP 3,pV#)a: Args: hidden_features (`torch.Tensor` of shape `(batch_size, num_patch, d_model)` in `flatten` mode or `(batch_size, n_vars, num_patch, d_model)` in `common_channel`/`mix_channel` mode.): Input hidden features. Returns: `torch.Tensor` of shape `(batch_size, prediction_length, nvars)`. c3D"TFqPRR4xK R#5i)r"Nr%r@)rU).0zs& r 8PatchTSMixerForPredictionHead.forward..PsC(Q[[R00(s c3L<"TFqRSP3,xK R#5i).N)rA)rNrOr-s& rrPrQVs$ [RZQ3(G(G#G!H!HRZs!$.r%r@)rIrDrF isinstancerrUrAr-hidden_featuresforecastsf& rr4%PatchTSMixerForPredictionHead.forward?s,,7,,_=++O< h & &uC(CuuC(CCH))"b1H  * * 6(E** 5 [RZ [5 ! [RZ [[$C)H)H$HIr )rFrDrIrAr1r6r?s@@rr:r:%s00$r r:cLaa]tRtRtoRtRV3RlV3RllltRtRtVtV;t #)PatchTSMixerLinearHeadi]zpLinear head for Classification and Regression. Args: config (`PatchTSMixerConfig`): Configuration. c <V^8dQhRS[/#rCr)rrs"rr#PatchTSMixerLinearHead.__annotate__es7717r c<\SV`4VPVnVPVnVPfVPpM^pW nVfJ\ P!VPVP,V,VP4Vn M8VPVPVP,V,4Vn VPf\ P!RR7VnM\ P!RR7Vn\ P!VP 4VnR#)Nr>r@)r&r'head_aggregation output_rangerbrJr(r)rJr num_targets projectionrGrHrIrrCr)r-rDrJ mul_factorr.s&&& rr'PatchTSMixerLinearHead.__init__es  & 7 7"//  " " *++JJ#6  & ii!:!::ZG""DO 2JJ!:!::ZGDO  " " *::3DL::3DLzz&"5"56 r c VPRR4pVPR8Xd VR,pMQVPR8XdVPRR7PpM#VPR8XdVP RR7pVP 'dVP V4pVP V4pVPV4pVPfmVPe_\P!V4VP^,VP^,, ,VP^,,pV#)a1 Args: hidden_features (`torch.Tensor` of shape `(batch_size x num_patch x d_model)` in `flatten` mode or `(batch_size x n_vars x num_patch x d_model)` in `common_channel`/`mix_channel` mode.): Input hidden features. Returns: `torch.Tensor` of shape `(batch_size x num_targets)`. use_lastmax_poolr#avg_poolr%r@).r%) rUr^maxvaluesrvrIrrarJr_rRsigmoid)r-rUs&&rr4PatchTSMixerLinearHead.forwards *33B;  J .-g6O  " "j 0-11b19@@O  " "j 0-22r2:O <<<"ll?;O,,7///:  $ $ ,43D3D3P o.$2C2CA2FIZIZ[\I]2]^aeararstauu r )rJrrIr^r_rar1r6r?s@@rrYrY]s778  r rYcvaa]tRtRtoRtRtRtRt]P!4V3Rl4t V3Rlt Rt Vt V;t#) PatchTSMixerPreTrainedModelimodel past_valuesFc <\SV`V4\V\4'dCVPP R8Xd&\ P!VPRRR7R#R#\V\4'dW\ P!VPP4\ P!VPP4R#R#)zInitialize weightsrgrg?)rvrwN)r& _init_weightsrSrYrDrminitnormal_r_rAzeros_rLrones_weight)r-rr.s&&rrq)PatchTSMixerPreTrainedModel._init_weightss f% f< = ={{33x? V00sD@  5 6 6 KK((-- . JJv''.. /7r c&<V^8dQh/S[;R&#rCr)rrs"rr(PatchTSMixerPreTrainedModel.__annotate__s r )time)r7r8r9r:base_model_prefixmain_input_nameinput_modalitiessupports_gradient_checkpointingrRno_gradrq__annotate_func__r<r=r>r?s@@rrmrms= #O &+# ]]_ 0 0r rmcHaa]tRtRtoRtV3RlV3RlltRtRtVtV;t #)PatchTSMixerPretrainHeadizSPretraining head. Args: config (`PatchTSMixerConfig`): Configuration. c <V^8dQhRS[/#rCr)rrs"rr%PatchTSMixerPretrainHead.__annotate__sLL1Lr c<\SV`4\P!VP4Vn\P !VPVP4Vn R#r1) r&r'r(rrCrDr)rJ patch_length base_pt_blockrMs&&rr'!PatchTSMixerPretrainHead.__init__sB ZZ(;(;<YYv~~v7J7JKr c JVPV4pVPV4pV#)aG Args: hidden_features (`torch.Tensor` of shape `(batch_size x num_patch x d_model)` in `flatten` mode or `(batch_size x n_vars x num_patch x d_model)` in `common_channel`/`mix_channel` mode.): Input hidden features. Returns: `torch.Tensor` of shape `(batch_size x n_vars x num_patch x patch_length)`. )rDrrTs&& rr4 PatchTSMixerPretrainHead.forwards),,_=%%o6r )rrDr6r?s@@rrrs LL  r rc vV^8dQhR\PR\R\R,R\R\ /#)rr2 mask_ratiounmasked_channel_indicesNchannel_consistent_masking mask_value)rRrSrlistrr)rs"rrrsB7%7% LL7%7%#Tk7%!% 7%  7%r cV^8gV^8d\RV R24hVPwrVrxVPp \V^V, ,4p V'd.\P !V^WyR7p V P ^V^4p M\P !WVWyR7p \P!WVWyR7p ^V RRRV 13&\P!V RR7p \P!V RR7p\P!V RVR7p V PR4P ^^^V4p Ve ^V RVRR3&VPV P4V4pWR ,3#) arandom_masking: Mask the input considering the control variables. Args: inputs (`torch.Tensor` of shape `(batch_size, num_channels, sequence_length, num_features)`): The input tensor to mask. mask_ratio (`float`): Masking ratio applied to mask the input data during random pretraining. It is the number between 0 and 1. unmasked_channel_indices (list, *optional*): Indices of channels that will not be masked. channel_consistent_masking (bool, *optional*, defaults to `False`): When true, masking will be same across all channels of a timeseries. Otherwise, masking positions will vary across channels. mask_value (int, *optional*, defaults to 0): Define the value of masked patches for pretraining. Returns: `tuple(torch.Tensor)`: inputs_mask, masked input, same shape as input Tensor and mask tensor of shape [bs x c x n] z Mask ratio z has to be between 0 and 1.devicerkNr#)r$indexr%.rl) rxrrrrRrandrepeatonesargsortgatherrp masked_fillr)r2rrrrr num_channelssequence_length num_featuresrlen_keepnoisemask ids_shuffle ids_restore inputs_masks&&&&& rrandom_maskingrsA4A~q;zl2MNOO>Dll;Jo ]]F?a*n56H! :q/I Q a0 :_T ::j ODDAyy--2.K-- 4K <<"K 8D >>"  $ $Q1l ;D+23Q(!Q ./$$TYY[*=K V $$r cV^8dQhR\PR\\,R\R,R\/#)rr2num_forecast_mask_patchesrNr)rRrSrr)rs"rrrsBA%A% LLA%#czA%#TkA% A%r c\V\4'dV.pVUu.uFp^NK ppVPwrgr\P!WgWP R7p .p ^p \ V4p \W4FUwrV^8:gW8d\RV R24h\Wo,V , 4pV PWV.4V V, p KW \V RR7p W8d)V ^,^,Wl, ,V ^,^&M-W8d(V R,^,W, ,V R,^&^pV FwpppVV,p^V VV1RV)R13&TpK! \P!V P^,4pV V,p V PR4P^^^V 4p Ve ^V RVRR3&VPV P4V4pVV R ,3#uupi) aiForecast masking that masks the last K patches where K is from the num_forecast_mask_patches. If num_forecast_mask_patches is a list, samples in the batch will be randomly masked by numbers defined in the list. Parameters: inputs (`torch.Tensor`): Input of shape `(bs, num_channels, num_patch, patch_length)` num_forecast_mask_patches (`list`): Number of patches to be masked at the end of each batch sample. e.g. 4 or [3, 5]. unmasked_channel_indices (`list`, *optional*): Indices of channels that are not masked. mask_value (`int`, *optional*, defaults to 0): Values in the masked patches will be filled by `mask_value`. Returns: `tuple(torch.Tensor)`: inputs_mask, masked input, same shape as inputs Tensor and Mask tensor of shape `(bs, num_channels , num_patch)` or `(bs, tsg1, tsg2, num_channels, num_patch)` rznum_forecast_mask_patches z6 should be greater than 0 and less than total patches.cV^,#rrz)xs&r"forecast_masking..@s!A$r )rrkNr%r)rSrrrRrarsumziprxr3sortedrandpermrprrr)r2rrrrforecast_mask_ratiosrrrrrt_list total_length total_ratiorratiotemp_lenbatch1 patch_lenbatch2permrs&&&& rforecast_maskingrs0+S11%>$?!'@A'@!A'@A>Dll;Jo ;;z WD FL*+K"#<S 1  ?,\N:pq z)K78 |H56  TF /F ay|z'@Aq !  "r 1 )BCr 1 F"( 1h("./VF]A z{ *+#) >>$**Q- (D :D >>"  $ $Q1l ;D+23Q(!Q ./$$TYY[*=K V $$OBs G*cTaa]tRtRtoRtV3RlV3RlltV3RlRltRtVtV;t #)PatchTSMixerPatchifyiYz A class to patchify the time series sequence into different patches Returns: `torch.Tensor` of shape `(batch_size, num_channels, num_patches, patch_length)` c <V^8dQhRS[/#rCr)rrs"rr!PatchTSMixerPatchify.__annotate__asII1Ir cB<\SV`4VPVnVPVnVP VnVPVP8:d'\ RVP RVP R24h\VPVP4VP, VP ,^,VnVPVP VP^, ,,pVPV, Vn R#)zSequence length (z+) has to be greater than the patch length ()N) r&r'context_lengthrr patch_striderxrhrbsequence_start)r-rDnew_sequence_lengthr.s&& rr'PatchTSMixerPatchify.__init__as %44"//"//   4#4#4 4#D$8$8#99deievevdwwxy    4 4d6G6GH4K\K\\aeararruvv"//$2C2CtGWGWZ[G[2\\"225HHr c4<V^8dQhRS[P/#)rrorQ)rrs"rrrrs5<<r c DVPR,pW P8wd\RV RVP R24hVRVPR1R3,pVP RVP VP R7pVPRR4P4pV#) z Parameters: past_values (`torch.Tensor` of shape `(batch_size, sequence_length, num_channels)`, *required*): Input for patchification Returns: `torch.Tensor` of shape `(batch_size, num_channels, num_patches, patch_length)` zInput sequence length (z%) doesn't match model configuration (rrkN) dimensionrstepr@r]) rrrxrunfoldrrrUr)r-rorrVs&& rr4PatchTSMixerPatchify.forwardrs&++B/ 22 2)/)::_`d`t`t_uuwx Q 3 3 5q89$2C2C$J[J[\!!"b)446 r )rbrrrrr6r?s@@rrrYs%II"r rcTaa]tRtRtoRtV3RlV3RlltV3RlRltRtVtV;t #)PatchTSMixerMaskingiap Class to perform random or forecast masking. Parameters: config (`PatchTSMixerConfig`): model config Returns: x_mask (`torch.Tensor` of shape `(batch_size, num_channels, num_patches, patch_length)`) Masked patched input mask (`torch.Tensor` of shape `(batch_size, num_channels, num_patches)`) Bool tensor indicating True on masked points c <V^8dQhRS[/#rCr)rrs"rr PatchTSMixerMasking.__annotate__s R R1 Rr cD<\SV`4VPVnVPVnVPVnVP VnVP VnVPVnVP e\VP 4VnR#R#r1) r&r'random_mask_ratior mask_typerrrrrMs&&rr'PatchTSMixerMasking.__init__s !'!9!9*0*K*K')))/)I)I&(.(G(G% ++  ( ( 4,243P3P,QD ) 5r c4<V^8dQhRS[P/#r}rQ)rrs"rrrs!"!"5<<!"r c tVPR8Xd<\VVPVPVPVP R7wr#MZVPR8Xd1\ VVPVPVP R7wr#M\RVP R24hVP4pW#3#)a Parameters: patch_input (`torch.Tensor` of shape `(batch_size, num_channels, num_patches, patch_length)`, *required*): Patch input Return: masked_input (`torch.Tensor` of shape `(batch_size, num_channels, num_patches, patch_length)`) Masked patched input mask (`torch.Tensor` of shape `(batch_size, num_channels, num_patches)`) Bool tensor indicating True on masked points rg)r2rrrrrV)r2rrrzInvalid mask type .) rrrrrrrrrxr)r-r~ masked_inputrs&& rr4PatchTSMixerMasking.forwards >>X %!/"11)-)F)F+/+J+J?? " L$^^z )!1"*.*H*H)-)F)F?? " L$1$..1ACD Dyy{!!r )rrrrrrr6r?s@@rrrs%  R R!"!"!"r rcTaa]tRtRtoRtV3RlV3RlltV3RlRltRtVtV;t #)PatchTSMixerStdScaleriz Standardize features by calculating the mean and scaling along the first dimension, and then normalizes it by subtracting from the mean and dividing by the standard deviation. c <V^8dQhRS[/#rCr)rrs"rr"PatchTSMixerStdScaler.__annotate__s``1`r c<\SV`4\VR4'd VPM^Vn\VR4'd VP MRVn\VR4'dVP VnR#RVnR#) scaling_dimkeepdimT minimum_scalegh㈵>N)r&r'hasattrrr$rrrMs&&rr'PatchTSMixerStdScaler.__init__sd )0)G)G6%%Q)0)C)Cv~~ 5>488UYUaUa>b%r rr1r6r?s@@rrr"s%NN    r rzS Base class for `PatchTSMixerEncoderOutput`, with potential hidden states. ) custom_introc8a]tRtRtoRtRtRtV3RltRtVt R#)PatchTSMixerEncoderOutputi=a last_hidden_state (`torch.FloatTensor` of shape `(batch_size, num_channels, num_patches, d_model)`): Hidden-state at the output of the last layer of the model. hidden_states (`tuple(torch.FloatTensor)`, *optional*): Hidden-states of the model at the output of each layer. Nc<V^8dQh/S[PR,;R&S[S[P,R,;R&#)rNlast_hidden_staterrR FloatTensorr)rrs"rr&PatchTSMixerEncoderOutput.__annotate__=s:((4/6**+d29r rz) r7r8r9r:r;rrrr<r=rs@rrr=s3759Mr rclaa]tRtRtoRtV3RlV3Rllt]]RV3RlRll44tRt Vt V;t #) PatchTSMixerEncoderiOz Encoder for PatchTSMixer which inputs patched time-series and outputs patched embeddings. Args: config (`PatchTSMixerConfig`): Configuration. c <V^8dQhRS[/#rCr)rrs"rr PatchTSMixerEncoder.__annotate__Xs  1 r c<\SV`V4\P!VPVP 4VnVP'd\VR7Vn MRVn \VR7Vn VP4R#r*) r&r'r(r)rrJpatcherr]rYpositional_encoderr&mlp_mixer_encoder post_initrMs&&rr'PatchTSMixerEncoder.__init__Xsf  yy!4!4fnnE  ) ) )&DF&SD #&*D #!2&!A r cN<V^8dQhRS[PRS[R,RS[/#)rror1Nre)rRrSrr)rrs"rrr$gs6!k!k\\!k#Tk!k # !kr c VeTMVPPpVPV4pVPeVPV4pVP WBR7wrV\ WVR7#)a past_values (`torch.FloatTensor` of shape `(batch_size, seq_length, num_input_channels)`): Context values of the time series. For a pretraining task, this denotes the input time series to predict the masked portion. For a forecasting task, this denotes the history/past time series values. Similarly, for classification or regression tasks, it denotes the appropriate context values of the time series. For univariate time series, `num_input_channels` dimension should be 1. For multivariate time series, it is greater than 1. Returns: `torch.FloatTensor` of shape `(batch_size, n_vars, num_patches, d_model)` r1)rr)rDr1r&r'r(r)r-ror1rpatchesrrs&&&, rr4PatchTSMixerEncoder.forwardeso.%9$D $++JjJj  ,,{+  " " .--g6G+/+A+A'+A+u((;Ljjr )r(r&r'r1 r7r8r9r:r;r'rrr4r<r=r>r?s@@rr"r"Os>  !k!k!k!kr r"zG Base class for model's outputs, with potential hidden states. cHa]tRtRtoRtRtRtRtRtRt Rt V3Rlt Rt Vt R#)PatchTSMixerModelOutputia last_hidden_state (`torch.FloatTensor` of shape `(batch_size, num_channels, num_patches, d_model)`): Hidden-state at the output of the last layer of the model. hidden_states (`tuple(torch.FloatTensor)`, *optional*): Hidden-states of the model at the output of each layer. patch_input (`torch.FloatTensor` of shape `(batch_size, num_channels, num_patches, patch_length)`): Patched input data to the model. mask (`torch.FloatTensor` of shape `(batch_size, num_channels, num_patches)`, *optional*): Bool Tensor indicating True in masked patches and False otherwise. loc (`torch.FloatTensor` of shape `(batch_size, 1, num_channels)`, *optional*): Gives the mean of the context window per channel. Used for revin denorm outside the model, if revin enabled. scale (`torch.FloatTensor` of shape `(batch_size, 1, num_channels)`, *optional*): Gives the std dev of the context window per channel. Used for revin denorm outside the model, if revin enabled. Nc><V^8dQh/S[PR,;R&S[S[P,R,;R&S[PR,;R&S[PR,;R&S[PR,;R&S[PR,;R&#)rNrrr~rrrr)rrs"rr$PatchTSMixerModelOutput.__annotate__s0((4/612**+d2934""T)056   d ")78   T !(9:   t #*;r rz)r7r8r9r:r;rrr~rrrrr<r=r s@rr2r2s2"3759M,0K%)D$(C&*E;r r2z= The PatchTSMixer Model for time-series forecasting. claa]tRtRtoRV3RlV3Rlllt]]RV3RlRll44tRtVt V;t #) PatchTSMixerModelic&<V^8dQhRS[RS[/#)rrD mask_input)rr)rrs"rrPatchTSMixerModel.__annotate__s1tr c <\SV`V4\V4Vn\ V4VnVRJd\ V4VnMRVnVPR8Xd\V4Vn MBVPR8XgVPRJd\V4Vn M\V4Vn VP4R#)z} mask_input (bool, *optional*, defaults to `False`): Whether to mask the input using the [`PatchTSMixerMasking`] module. TNrvrw)r&r'r"encoderrpatchingrmaskingrrscalerrrr))r-rDr8r.s&&&rr'PatchTSMixerModel.__init__s  *62 ,V4  .v6DLDL >>V #08DK ^^u $$(>/7DK/7DK r cv<V^8dQhRS[PRS[PR,RS[R,RS[/#)rro observed_maskNr1re)rRrSrr2)rrs"rrr9sD5 5 \\5 ||d*5 #Tk 5 ! 5 r c VeTMVPPpRpVf\P!V4pVP W4wrgpVP V4p T p VP eVP V 4wrVPV VR7p \V \4'd \V !p \V PV PV VVVR7#)a past_values (`torch.FloatTensor` of shape `(batch_size, seq_length, num_input_channels)`): Context values of the time series. For a pretraining task, this denotes the input time series to predict the masked portion. For a forecasting task, this denotes the history/past time series values. Similarly, for classification or regression tasks, it denotes the appropriate context values of the time series. For univariate time series, `num_input_channels` dimension should be 1. For multivariate time series, it is greater than 1. observed_mask (`torch.FloatTensor` of shape `(batch_size, sequence_length, num_input_channels)`, *optional*): Boolean mask to indicate which `past_values` were observed and which were missing. Mask values selected in `[0, 1]`: - 1 for values that are **observed**, - 0 for values that are **missing** (i.e. NaNs that were replaced by zeros). Nr-)rrr~rrr)rDr1rRrr>r<r=r;rSrrr2rr) r-rorAr1rrscaled_past_valuesrr patched_x enc_inputencoder_outputs &&&&, rr4PatchTSMixerModel.forwards0%9$D $++JjJj   !OOK8M)-[)P&MM"45  << #"ll95OI !5&  ne , ,6GN&,>>(66!   r )r;r=r<r>r8NN r7r8r9r:r'rrr4r<r=r>r?s@@rr6r6s5 25 5 5 5 r r6z> Output type of [`PatchTSMixerForPreTrainingOutput`]. c@a]tRtRtoRtRtRtRtRtV3Rlt Rt Vt R#) PatchTSMixerForPreTrainingOutputia loss (*optional*, returned when `y` is provided, `torch.FloatTensor` of shape `()`): Total loss prediction_outputs (`torch.FloatTensor` of shape `(batch_size, num_input_channels, num_patches, patch_length)`): Prediction output from the pretrain head. last_hidden_state (`torch.FloatTensor` of shape `(batch_size, num_input_channels, num_patches, d_model)`): Backbone embeddings before passing through the head. hidden_states (`tuple(torch.FloatTensor)`, *optional*): Hidden-states of the model at the output of each layer. Nc<V^8dQh/S[PR,;R&S[PR,;R&S[PR,;R&S[S[P,R,;R&#rNlossprediction_outputsrrr)rrs"rr-PatchTSMixerForPreTrainingOutput.__annotate__j$   d ")%&))D07'(((4/6)***+d29+r rz r7r8r9r:r;rNrOrrrr<r=r s@rrKrK) &*D372659M+r rKz. `PatchTSMixer` for mask pretraining. chaa]tRtRtoV3RlV3Rllt]]RV3RlRll44tRtVt V;t #)PatchTSMixerForPretrainingic <V^8dQhRS[/#rCr)rrs"rr'PatchTSMixerForPretraining.__annotate__"s1r c<\SV`V4\VRR7Vn\ VR7VnVP VnVP4R#)T)r8rN)r&r'r6rnrhead masked_lossr)rMs&&rr'#PatchTSMixerForPretraining.__init__"sD  &v$? ,F; !-- r c |<V^8dQhRS[PRS[PR,RS[R,RS[RS[/#)rrorANr1 return_lossre)rRrSrrK)rrs"rrrW-sN: : \\: ||d*: #Tk :  :  *: r c VeTMVPPpVPRJd"\PP RR7pM \PP RR7pVP VVVR7p\V\4'd \V!pVPVP4pVRJdV!WP4p MRp VPRJd\V eXV PR R7VP,P4VPP4R,, p \!V VVPVP"R 7#) a past_values (`torch.FloatTensor` of shape `(batch_size, seq_length, num_input_channels)`): Context values of the time series. For a pretraining task, this denotes the input time series to predict the masked portion. For a forecasting task, this denotes the history/past time series values. Similarly, for classification or regression tasks, it denotes the appropriate context values of the time series. For univariate time series, `num_input_channels` dimension should be 1. For multivariate time series, it is greater than 1. observed_mask (`torch.FloatTensor` of shape `(batch_size, sequence_length, num_input_channels)`, *optional*): Boolean mask to indicate which `past_values` were observed and which were missing. Mask values selected in `[0, 1]`: - 1 for values that are **observed**, - 0 for values that are **missing** (i.e. NaNs that were replaced by zeros). return_loss (`bool`, *optional*): Whether to return the loss in the `forward` call. NTnone reductionrvrAr1r#rrNrOrrr%)rDr1rZrRr(MSELossrnrSrr2rYrr~rvrrrKr) r-rorAr1r]rrN model_outputx_hatloss_vals &&&&&, rr4"PatchTSMixerForPretraining.forward+s<6%9$D $++JjJj    t #88##f#5D88##f#5Dzz '!5" lE * *2LAL ,889 $ E#;#;<V^8dQh/S[PR,;R&S[PR,;R&S[PR,;R&S[S[P,R,;R&S[PR,;R&S[PR,;R&#)rNrNrOrrrrr)rrs"rr,PatchTSMixerForPredictionOutput.__annotate__js,   d ")-.))D07/0((4/612**+d2934   T !(56   t #*7r rz)r7r8r9r:r;rNrOrrrrrr<r=r s@rrkrkjs3 &*D372659M$(C&*E7r rkz Base class for time series model's predictions outputs that contains the sampled values from the chosen distribution. c4a]tRtRtoRtRtV3RltRtVtR#)"SamplePatchTSMixerPredictionOutputi sequences (`torch.FloatTensor` of shape `(batch_size, num_samples, prediction_length, number_channels)`): Sampled values from the chosen distribution. NcH<V^8dQh/S[PR,;R&#rN sequencesrRr)rrs"rr/SamplePatchTSMixerPredictionOutput.__annotate__  4'.r rz r7r8r9r:r;rsrr<r=r s@rroro +/Ir roc4a]tRtRtoRtRtV3RltRtVtR#)"SamplePatchTSMixerRegressionOutputirpNcH<V^8dQh/S[PR,;R&#rrrt)rrs"rr/SamplePatchTSMixerRegressionOutput.__annotate__rvr rzrwr s@rrzrzrxr rzcV^8dQhR\PPR\PR\P/#)rinputtargetre)rR distributions DistributionrS)rs"rrrs5##u""//##%,,#r c&VPV4)#)z[ Computes the negative log likelihood loss from input distribution with respect to target. )log_prob)r~rs&&rnllrs NN6 " ""r cV^8dQhR\PR\PR,R\P/#)r input_tensorweightsNrerQ)rs"rrrs5**5<<*%,,:M*chcoco*r cVe\P!V^8gW,\P!V44p\P!V'dVP VR7MVP 4RR7pV'dVP VR7V, #VP 4V, #VP VR7#)a: Computes the weighted average of a given tensor across a given `dim`, masking values associated with weight zero, meaning instead of `nan * 0 = nan` you will get `0 * 0 = 0`. Args: input_tensor (`torch.FloatTensor`): Input tensor, of which the average must be computed. weights (`torch.FloatTensor`, *optional*): Weights tensor, of the same shape as `input_tensor`. dim (`int`, *optional*): The dim along which to average `input_tensor`. Returns: `torch.FloatTensor`: The tensor with values averaged along the specified `dim`. r#rr)rRrrrrrv)rrr$weighted_tensor sum_weightss&&& rweighted_averagers ++glL4JEL\L\]iLjkkk#'++#+"67;;=VYZ 03###,R]]]9L9L9NR]]]  S ))r caa]tRtRtoRtV3RlV3Rllt]]R V3RlRll44t] P!4R V3RlRll4t R t Vt V;t#) PatchTSMixerForPredictioniz `PatchTSMixer` for forecasting application. Args: config (`PatchTSMixerConfig`): Configuration. Returns: `None`. c <V^8dQhRS[/#rCr)rrs"rr&PatchTSMixerForPrediction.__annotate__s1r c<\SV`V4VPVnVPVnVPVnVPR8Xd RVnMfVP pR\R\R\/pVPVP 4pVeV!VR7VnM\RVP 24h\V4Vn \VVP R7VnVP!4R#)mseN student_tnormalnegative_binomialr#Unknown distribution output rDrJ)r&r'rNrAnum_parallel_samplesrJrEr r r getrxr6rnr:rYr))r-rDr$distribution_output_map output_classr.s&& rr'"PatchTSMixerForPrediction.__init__s  KK *0*K*K'$*$?$?! ;;% '+D $**C^,#%;' # 366v7Q7QRL'+7C+@( #?@Z@Z?[!\]]&v. 1 $ 8 8  r c <V^8dQhRS[PRS[PR,RS[PR,RS[R,RS[RS[/#)rrorAN future_valuesr1r]re)rRrSrrk)rrs"rrrsik k \\k ||d*k ||d* k #Tk k  k  )k r c VPR8Xd\P!RR7pM#VPR8Xd\pM \ R4hVeTMVP P pVPVVVR7p\V\4'd \V!pVPVP4p Rp VPEe VP'dVPPV VP RVP3,VP"RVP3,R 7p Ve.VR Jd(V!V VRVP3,4p \%V 4p EMWP"RVP3,,VP RVP3,,p Ve"VR JdV!WRVP3,4p MVP'dPVPPWP VP"R 7p VeVR JdV!W4p \%V 4p M5WP",VP ,p VeVR Jd V!W4p VPe@VP RVP3,p VP"RVP3,p MVP p VP"p \'V V VPVP(V V R 7#) a past_values (`torch.FloatTensor` of shape `(batch_size, seq_length, num_input_channels)`): Context values of the time series. For a pretraining task, this denotes the input time series to predict the masked portion. For a forecasting task, this denotes the history/past time series values. Similarly, for classification or regression tasks, it denotes the appropriate context values of the time series. For univariate time series, `num_input_channels` dimension should be 1. For multivariate time series, it is greater than 1. observed_mask (`torch.FloatTensor` of shape `(batch_size, sequence_length, num_input_channels)`, *optional*): Boolean mask to indicate which `past_values` were observed and which were missing. Mask values selected in `[0, 1]`: - 1 for values that are **observed**, - 0 for values that are **missing** (i.e. NaNs that were replaced by zeros). future_values (`torch.FloatTensor` of shape `(batch_size, target_len, num_input_channels)` for forecasting,: `(batch_size, num_targets)` for regression, or `(batch_size,)` for classification, *optional*): Target values of the time series, that serve as labels for the model. The `future_values` is what the Transformer needs during training to learn to output, given the `past_values`. Note that, this is NOT required for a pretraining task. For a forecasting task, the shape is be `(batch_size, target_len, num_input_channels)`. Even if we want to forecast only specific channels by setting the indices in `prediction_channel_indices` parameter, pass the target data with all channels, as channel Filtering for both prediction and target will be manually applied before the loss computation. return_loss (`bool`, *optional*): Whether to return the loss in the `forward` call. rrvr`r2Invalid loss function: Allowed values: mse and nllNrb.rrT)rNrOrrrr)rNr(rdrrxrDr1rnrSrr2rYrrArJ distributionrrrrkr)r-rorArr1r]rrNrey_hatrgrrrs&&&&&&, rr4!PatchTSMixerForPrediction.forwardsJ 99 ::/D YY% DQR R%9$D $++JjJj  zz '!5" lE * *2LAL ,889  * * 6'''#77DD$((d.M.M)MN&,,S$2Q2Q-QR E  !,1D#$%c4+J+J&JK H 09H..sD4S4S/STT"&&sD,K,K'KLM!,1D#Ed>]>]9]+^_H'''#77DD//|7I7I E  !,1D#L@H/9H 2 22\5E5EE ,1D#E9H  * * 6""3(G(G#GHC &&sD,K,K'KLE""C &&E.$*<<&44   r cb<V^8dQhRS[PRS[PR,RS[/#)rrorANre)rRrSro)rrs"rrrcs;-E-E\\-E||d*-E , -Er c JVPpV!VRVRR7pVPPVPVPVP R7p\ V4Uu.uFqeP4NK pp\P!V^R7p\VR7#uupi)aX Generate sequences of sample predictions from a model with a probability distribution head. Args: past_values (`torch.FloatTensor` of shape `(batch_size, sequence_length, num_input_channels)`): Past values of the time series that serves as context in order to predict the future. observed_mask (`torch.BoolTensor` of shape `(batch_size, sequence_length, num_input_channels)`, *optional*): Boolean mask to indicate which `past_values` were observed and which were missing. Mask values selected in `[0, 1]`: - 1 for values that are **observed**, - 0 for values that are **missing** (i.e. NaNs that were replaced by zeros). Return: [`SamplePatchTSMixerPredictionOutput`] where the outputs `sequences` tensor will have shape `(batch_size, number of samples, prediction_length, num_input_channels)`. NF)rorrAr1rr#rs) rrJrrOrrr-samplerRstackro)r-rorAroutputsrrsampless&&& rgenerate"PatchTSMixerForPrediction.generatebs2 $88#'!&  //<<  & &GKKw}}= 388L2MN2MQ&&(2MN++g1-1GDD Os"B )rJrYrNrnrrA)NNNTr1)r7r8r9r:r;r'rrr4rRrrr<r=r>r?s@@rrrsa <k k k Z ]]_-E-E-E-Er rzK Output type of [`PatchTSMixerForTimeSeriesClassificationOutput`]. c@a]tRtRtoRtRtRtRtRtV3Rlt Rt Vt R#)-PatchTSMixerForTimeSeriesClassificationOutputia, loss (*optional*, returned when `y` is provided, `torch.FloatTensor` of shape `()`): Total loss. prediction_outputs (`torch.FloatTensor` of shape `(batch_size, num_labels)`): Prediction output from the classification head. last_hidden_state (`torch.FloatTensor` of shape `(batch_size, num_input_channels, num_patches, d_model)`): Backbone embeddings before passing through the head. hidden_states (`tuple(torch.FloatTensor)`, *optional*): Hidden-states of the model at the output of each layer plus the optional initial embedding outputs. Nc<V^8dQh/S[PR,;R&S[PR,;R&S[PR,;R&S[S[P,R,;R&#rMr)rrs"rr:PatchTSMixerForTimeSeriesClassificationOutput.__annotate__rQr rzrRr s@rrrrSr rclaa]tRtRtoRtV3RlV3Rllt]]RV3RlRll44tRt Vt V;t #) 'PatchTSMixerForTimeSeriesClassificationiz `PatchTSMixer` for classification application. Args: config (`PatchTSMixerConfig`): Configuration. Returns: `None`. c <V^8dQhRS[/#rCr)rrs"rr4PatchTSMixerForTimeSeriesClassification.__annotate__s  1 r c<\SV`V4\V4Vn\ VR7VnVP R9d(\VPVPR7Vn MRVn VP4R#)rrJrbNrwrvT) r&r'r6rnrYrYrInjectScalerStatistics4DrJrb inject_scaler)rMs&&rr'0PatchTSMixerForTimeSeriesClassification.__init__sh  &v. *   >>2 2 8]c]o]o pD  $D  r c |<V^8dQhRS[PRS[PR,RS[R,RS[RS[/#rro target_valuesNr1r]re)rRrSrr)rrs"rrrsUC C \\C ||d*C #Tk C  C  7C r c \PP4pVeTMVPPpVP VVR7p\ V\4'd \V!pVPe8VPVPVPVPR7Vn VPVP4pVeVRJd V!W4p MRp \V VVPVPR7#)aH past_values (`torch.FloatTensor` of shape `(batch_size, seq_length, num_input_channels)`): Context values of the time series. For a pretraining task, this denotes the input time series to predict the masked portion. For a forecasting task, this denotes the history/past time series values. Similarly, for classification or regression tasks, it denotes the appropriate context values of the time series. For univariate time series, `num_input_channels` dimension should be 1. For multivariate time series, it is greater than 1. target_values (`torch.FloatTensor` of shape `(batch_size, target_len, num_input_channels)` for forecasting, `(batch_size, num_targets)` for regression, or `(batch_size,)` for classification, *optional*): Target values of the time series, that serve as labels for the model. The `target_values` is what the Transformer needs during training to learn to output, given the `past_values`. Note that, this is NOT required for a pretraining task. For a forecasting task, the shape is be `(batch_size, target_len, num_input_channels)`. Even if we want to forecast only specific channels by setting the indices in `prediction_channel_indices` parameter, pass the target data with all channels, as channel Filtering for both prediction and target will be manually applied before the loss computation. For a classification task, it has a shape of `(batch_size,)`. For a regression task, it has a shape of `(batch_size, num_targets)`. return_loss (`bool`, *optional*): Whether to return the loss in the `forward` call. Nr-rTrc)rRr(CrossEntropyLossrDr1rnrSrr2rrrrrYrr) r-rorr1r]rrNrerrgs &&&&&, rr4/PatchTSMixerForTimeSeriesClassification.forwardsJxx((*%9$D $++JjJj zz !5"  lE * *2LAL    (-1->->.. $$"((.?.L *  ,889  $)<E1HH<$*<<&44   r )rYrrnrir0r?s@@rrrs>   C C C C r rz= Output type of [`PatchTSMixerForRegressionOutput`]. c@a]tRtRtoRtRtRtRtRtV3Rlt Rt Vt R#)PatchTSMixerForRegressionOutputia) loss (*optional*, returned when `y` is provided, `torch.FloatTensor` of shape `()`): Total loss. regression_outputs (`torch.FloatTensor` of shape `(batch_size, num_targets)`): Prediction output from the regression head. last_hidden_state (`torch.FloatTensor` of shape `(batch_size, num_input_channels, num_patches, d_model)`): Backbone embeddings before passing through the head. hidden_states (`tuple(torch.FloatTensor)`, *optional*): Hidden-states of the model at the output of each layer plus the optional initial embedding outputs. Nc<V^8dQh/S[PR,;R&S[PR,;R&S[PR,;R&S[S[P,R,;R&#)rNrNregression_outputsrrr)rrs"rr,PatchTSMixerForRegressionOutput.__annotate__rQr rz) r7r8r9r:r;rNrrrrr<r=r s@rrrrSr rcTaa]tRtRtoRV3RlV3RllltV3RlRltRtVtV;t#)ri&c,<V^8dQhRS[RS[RS[/#)rrJrb expansionr)rrs"rr%InjectScalerStatistics4D.__annotate__'s"'''#'#'r cR<\SV`4\P!V^,W1,4Vn\P!W1,V4Vn\P!^^V,4Vn\P!^V,^4VnW nR#)rN) r&r'r(r)inverse_trans_expansioninverse_trans_compressionmap_scale_expansionmap_scale_compressionrb)r-rJrbrr.s&&&&rr'!InjectScalerStatistics4D.__init__'sr ')yy1i>Q'R$)+93F)P&#%99QI #> %'YYq9}a%@"&r ch<V^8dQhRS[PRS[PRS[P/#)rr2rrrQ)rrs"rrr0s.ellellr c VPRR4pVPR4pVP^^VP^4pVPRR4pVPR4pVP^^VP^4p\P !WE.RR7pVP V4pVPV4p\P !W.RR7pVPV4pVPV4pV#)aQ Args: inputs (`torch.Tensor` of shape `(batch_size, num_input_channels, num_patch, d_model)`) loc (`torch.Tensor` of shape `(batch_size, 1, num_input_channels)`) scale (`torch.Tensor` of shape `(batch_size, 1, num_input_channels)`) Returns: `torch.Tensor` of shape `(batch_size, num_input_channels, num_patch, d_model)` r#r%r@) rUrprrbrRcatrrrr)r-r2rrrvstdev concat_statss&&&& rr4 InjectScalerStatistics4D.forward0s}}R$~~b!{{1a!1!115B'# Q4#3#3Q7yy$B7 // = 11,? F1r:--f5//7 r )rrrrrbrrr?s@@rrr&s''r rz4 `PatchTSMixer` for regression application. caa]tRtRtoV3RlV3Rllt]]R V3RlRll44t]P!4V3RlRl4t Rt Vt V;t #) PatchTSMixerForRegressioniNc <V^8dQhRS[/#rCr)rrs"rr&PatchTSMixerForRegression.__annotate__Ts##1#r c|<\SV`V4\V4VnVPVnVP VnVP VnVPR8Xd RVnMdR\R\R\/pVPVP 4pVeV!VPR7VnM\RVP 24hVPR 9d(\VPVP R7VnMRVn\%VVP R7VnVP)4R#) rNrrrr#rrrr)r&r'r6rnrNrJrr r r rr`rxrrrJrbrrYrYr))r-rDrrr.s&& rr'"PatchTSMixerForRegression.__init__Ts  &v. KK #)#=#= $*$?$?! ;;% '+D $^,#%;' # 366v7Q7QRL'+7F>2 2 8]c]o]o pD  $D * $ 8 8  r c |<V^8dQhRS[PRS[PR,RS[R,RS[RS[/#r)rRrSrr)rrs"rrr{sUP P \\P ||d*P #Tk P  P  )P r c aSPR8Xd\P!RR7pM#SPR8Xd\pM \ R4hVeTMSP P pSPVVR7p\V\4'd \V!pSPe8SPVPVPVPR7Vn SPVP4pVeVR JdSP 'dSP R 8Xd+\"P$!V^84'd \'R 4hSP P)V4p \;QJd.V3R lV4FNK 5M!V3R lV44pV!W4p \+V 4p M V!W4p MRp \-V VVPVP.R 7#)aD past_values (`torch.FloatTensor` of shape `(batch_size, seq_length, num_input_channels)`): Context values of the time series. For a pretraining task, this denotes the input time series to predict the masked portion. For a forecasting task, this denotes the history/past time series values. Similarly, for classification or regression tasks, it denotes the appropriate context values of the time series. For univariate time series, `num_input_channels` dimension should be 1. For multivariate time series, it is greater than 1. target_values (`torch.FloatTensor` of shape `(batch_size, target_len, num_input_channels)` for forecasting, `(batch_size, num_targets)` for regression, or `(batch_size,)` for classification, *optional*): Target values of the time series, that serve as labels for the model. The `target_values` is what the Transformer needs during training to learn to output, given the `past_values`. Note that, this is NOT required for a pretraining task. For a forecasting task, the shape is be `(batch_size, target_len, num_input_channels)`. Even if we want to forecast only specific channels by setting the indices in `prediction_channel_indices` parameter, pass the target data with all channels, as channel Filtering for both prediction and target will be manually applied before the loss computation. For a classification task, it has a shape of `(batch_size,)`. For a regression task, it has a shape of `(batch_size, num_targets)`. return_loss (`bool`, *optional*): Whether to return the loss in the `forward` call. rrvr`rrNr-rTrzDtarget_values cannot be negative for negative_binomial distribution.c3n<"TF*qPRSPP4xK, R#5i)r"Nr%)rrDr`)rNitemr-s& rrP4PatchTSMixerForRegression.forward..s)WQViiDKK,C,CDDQVs25)rNrrr)rNr(rdrrxrDr1rnrSrr2rrrrrYrJrRany Exceptionrrrr) r-rorr1r]rrNrerrrgs f&&&&, rr4!PatchTSMixerForRegression.forwardysH 99 ::/D YY% DQR R%9$D $++JjJj zz !5"  lE * *2LAL    (-1->->.. $$"((.?.L *  ,889  $)<'''++/BBuyyQ^abQbGcGc#$jkk#77DDUK WQVWWQVWW <+H55H.$*<<&44   r c:<V^8dQhRS[PRS[/#)rrore)rRrSrz)rrs"rrrs'#E#E\\#E ,#Er c bVPpV!VRRR7pVPPVP4p\ V4Uu.uFqTP 4NK pp\ P!V^R7PRW PP4p\VR7#uupi)a Generate sequences of sample predictions from a model with a probability distribution head. Args: past_values (`torch.FloatTensor` of shape `(batch_size, sequence_length, num_input_channels)`): Past values of the time series that serves as context in order to predict the target values. Return: [`SamplePatchTSMixerRegressionOutput`] where the outputs `sequences` tensor will have shape `(batch_size, number of samples, num_targets)`. NF)rorr1r#rr%) rrJrrr-rrRrrrDr`rz)r-rorrrrrs&& rr"PatchTSMixerForRegression.generates" $88#!& //<r?s@@rrrNsW ##JP P P d ]]_#E#E#Er r)Nr)NFrl)NrlrH)rmr6rUrrr)Nr;rrcollections.abcr dataclassesrrRtorch.nnr(transformers.modeling_utilsrtransformers.utilsrrrrmodeling_flash_attention_utilsrmodeling_utilsrprocessing_utilsr time_series_utilsr r r utilsr rrrconfiguration_patchtsmixerr get_loggerr7loggerrrrArYrrrrrrr rr&r:rYrmrrrrrrrrrr"r2r6rKrUrkrorzrrrrrrrr__all__rzr rrs " $! 7*&B5&UURR:   H %*&BII&,$RYY$N.BII.bbii.-299-b%:R)BIIR)jCbiiCL* *Z# #L&# &#R5BII5pDRYYDN0/00*ryy>7%vA%J-299-b9""))9"z 0BII 0H3;RYY3;n BII 6   : :  :9k59kx  +k+  +4 Q 3Q  Q h  :{:  :$ F !<F  F R  +k+  +0  // /  // /#*0GE ;GET  :K:  :$` .I` F  :k:  :$%ryy%P ^E ;^E  ^EB r