jASrSSKrSSKJr SSKJr SSKrSSKJr SSK J r SSK J r SSK Jr SS KJr SS KJr SS KJr SS KJrJrJr SS KJrJrJrJr SSKJ r \RB"\"5r#"SS\RH5r%"SS\RH5r&"SS\RH5r'"SS\RH5r("SS\RH5r)"SS\RH5r*SzS\RHS\RVS\RVS\RVS \RVS-S!\,S-S"\,S#\\4S$jjr-"S%S&\RH5r."S'S(\RH5r/"S)S*\RH5r0"S+S,\RH5r1"S-S.\RH5r2"S/S0\RH5r3"S1S2\RH5r4\"S3S4\ 55r5"S5S6\RH5r6S{S7\RVS8\,S9\7S-S:\8S;\94 S<jjr:S|S7\RVS=\7\9-S9\7S-S;\94S>jjr;"S?S@\RH5r<"SASB\RH5r="SCSD\RH5r>"SESF\RH5r?"SGSH\RH5r@\"SISJ9\"SKSL\ 555rA"SMSN\55rB\"SOSJ9\"SPSQ\ 555rC\"SRSJ9"SSST\555rD\"SUSJ9\"SVSW\ 555rE\"SXSJ9"SYSZ\555rF\"S[SJ9\"S\S]\ 555rG\"S^SJ9\"S_S`\ 555rH\"S^SJ9\"SaSb\ 555rISc\RRSd\RVSe\RV4SfjrLS}Sg\RVSh\RVS-Se\RV4SijjrM"SjSk\55rN\"SlSJ9\"SmSn\ 555rO"SoSp\55rP\"SqSJ9\"SrSs\ 555rQ"StSu\RH5rR\"SvSJ9"SwSx\555rS/SyQrTg)~zPyTorch PatchTSMixer model.N)Callable) dataclass)PreTrainedModel) ModelOutput)initialization)FlashAttentionKwargs)ALL_ATTENTION_FUNCTIONS)Unpack)NegativeBinomialOutput NormalOutputStudentTOutput)TransformersKwargsauto_docstringcan_return_tuplelogging)PatchTSMixerConfigc>^\rSrSrSrS\S\4U4SjjrSrSrU=r $)PatchTSMixerGatedAttention&z Module that applies gated attention to input data. Args: in_size (`int`): The input size. out_size (`int`): The output size. in_sizeout_sizec>[TU]5 [R"X5Ul[R "SS9Ulg)Ndim)super__init__nnLinear attn_layerSoftmax attn_softmax)selfrr __class__s C:\Users\johnn\AppData\Local\Packages\PythonSoftwareFoundation.Python.3.13_qbz5n2kfra8p0\LocalCache\local-packages\Python313\site-packages\transformers/models/patchtsmixer/modeling_patchtsmixer.pyr#PatchTSMixerGatedAttention.__init__/s/ ))G6JJ2.cNURURU55nX-nU$N)r$r")r%inputs attn_weights r'forward"PatchTSMixerGatedAttention.forward4s(''(?@ % r))r"r$) __name__ __module__ __qualname____firstlineno____doc__intrr.__static_attributes__ __classcell__r&s@r'rr&s%//s/ r)rcV^\rSrSrSrS\4U4SjjrS\R4Sjr Sr U=r $)PatchTSMixerBatchNorm;zH Compute batch normalization over the sequence length (time) dimension. configc~>[TU]5 [R"URUR S9Ulg)Neps)rrr BatchNorm1dd_modelnorm_eps batchnormr%r<r&s r'rPatchTSMixerBatchNorm.__init__@s( FOOLr)r,clURSS5nURU5nURSS5$)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)` r) transposerC)r%r,outputs r'r.PatchTSMixerBatchNorm.forwardDs7!!!Q''1%%r))rC r0r1r2r3r4rrtorchTensorr.r6r7r8s@r'r:r:;s,M1M &ell & &r)r:c^\rSrSrSrS\4U4Sjjr\S\S\R4Sj5r S\ R4Sjr S rU=r$) PatchTSMixerPositionalEncodingQz Class for positional encoding r<c>[TU]5 UR(aURU5Ulg[ R "[R"URUR55Ulgr+) rruse_positional_encoding_init_pe position_encr ParameterrLzeros num_patchesrArDs r'r'PatchTSMixerPositionalEncoding.__init__VsN   ) ) $ f 5D  " U[[9K9KV^^-\ ]D r)returncdURS:Xa@[R"[R"UR UR 5SS9nU$URS:XGa8[R"UR UR 5n[R"SUR 5RS5n[R"[R"SUR S5[R"S5UR - *-5n[R"X#-5USS2SSS24'[R"X#-5USS2SSS24'XR5- nXR!5S -- n[R"US S9nU$[#URS 35e) NrandomT requires_gradsincosrrrGg@ FzN is not a valid positional encoder. Available types are 'random' and 'sincos'.)positional_encoding_typer rUrLrandnrWrArVarange unsqueezeexpmathlogsincosmeanstd ValueError)r<rTpositiondiv_terms r'rS'PatchTSMixerPositionalEncoding._init_pe^sn  * *h 6<< F4F4F(WgklL , , 8 ;;v'9'96>>JL||Av'9'9:DDQGHyya!CQXHY\b\j\jHjFk!klH$)IIh.A$BLADqD !$)IIh.A$BLADqD !'*;*;*==L'+;+;+=+BCL<< EJL 2234BC r) patch_inputc"XR-nU$r+rT)r%ro hidden_states r'r.&PatchTSMixerPositionalEncoding.forwardrs"%6%66 r)rq)r0r1r2r3r4rr staticmethodr rUrSrLrMr.r6r7r8s@r'rOrOQsS^1^+ &5<<r)rOcV^\rSrSrSrS\4U4SjjrS\R4Sjr Sr U=r $)PatchTSMixerNormLayerxzUNormalization block Args: config (`PatchTSMixerConfig`): Configuration. r<c>[TU]5 URUlSURR5;a[ U5Ulg[ R"URURS9Ulg)Nbatchr>) rrnorm_mlplowerr:normr LayerNormrArBrDs r'rPatchTSMixerNormLayer.__init__sT  foo++- --f5DI V^^IDIr)r,clSURR5;a[R"UURSURS-URSURS45nUR U5n[R"X!R5nU$UR U5nU$)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))` ryrrrGr)rzr{rLreshapeshaper|)r%r,inputs_reshapeds r'r.PatchTSMixerNormLayer.forwards dmm))+ +#mmLLOfll1o5LLOLLOO#ii8O]]?LLAF  YYv&F r))r|rzrKr8s@r'rvrvxs,J1Jellr)rvcJ^\rSrSrU4SjrS\R 4SjrSrU=r $)PatchTSMixerMLPc>>[TU]5 XR-n[R"X5Ul[R "UR5Ul[R"XB5Ul [R "UR5Ul gr+) rrexpansion_factorr r!fc1Dropoutdropoutdropout1fc2dropout2)r% in_features out_featuresr< num_hiddenr&s r'rPatchTSMixerMLP.__init__sd  #:#:: 99[5 6>>2 99Z6 6>>2 r)r,cUR[RRUR U555nUR U5nUR U5nU$)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%r,s r'r.PatchTSMixerMLP.forwardsKr}}11$((62BCD&!v& r))rrrr) r0r1r2r3rrLrMr.r6r7r8s@r'rrs3 ell  r)rcV^\rSrSrSrS\4U4SjjrS\R4Sjr Sr U=r $)$PatchTSMixerChannelFeatureMixerBlockzzThis module mixes the features in the channel dimension. Args: config (`PatchTSMixerConfig`): Configuration. r<c>[TU]5 [U5UlURUl[ UR UR US9UlUR(a$[UR UR S9Ul ggNrrr<rr) rrrvr| gated_attnrnum_input_channelsmlpr gating_blockrDs r'r-PatchTSMixerChannelFeatureMixerBlock.__init__sv )&1  ++"1122     :11FL==((6??([L,,|3K''1-88:K  $$r)c^\rSrSrSrSS\S\S\S\S\S \S \S-4U4S jjjr SS \ RS \ RS-S\ RS-S\S-S\ \ S\\ R\ RS-44 SjjrSrU=r$)PatchTSMixerAttentioniz=Multi-headed attention from 'Attention Is All You Need' paperN embed_dim num_headsr is_decoderbias is_causalr<c>[TU]5 XlX lX0lX-UlXplUR U-UR:wa[SURSUS35eUR S-UlX@l X`l [R"XUS9Ul [R"XUS9Ul[R"XUS9Ul[R"XUS9Ulg)Nz;embed_dim must be divisible by num_heads (got `embed_dim`: z and `num_heads`: ).r)r)rrrrrhead_dimr<rkrrrr r!k_projv_projq_projout_proj) r%rrrrrrr<r&s r'rPatchTSMixerAttention.__init__s "" !.  MMI %$.. 8MdnnM]$YKr3 }}d* $"ii 4@ ii 4@ ii 4@  )TB r) hidden_stateskey_value_statesroutput_attentionsrrYc USLnURSSn/UQSPURP7nURU5RU5R SS5n U(aUOUn /U RSSQSPURP7n UR U 5RU 5R SS5n UR U 5RU 5R SS5n [R"URR[5nU"UU U U U4UR(dSO URURUS.UD6unnUR"/UQSP76R!5nUR#U5nUU4$)z#Input shape: Batch x Time x ChannelNrrrG)rrr)rrrviewrHrrr get_interfacer<_attn_implementationrrrrrrr)r%rrrrris_cross_attention input_shape hidden_shape query_statescurrent_stateskv_shape key_states value_statesattention_interfacerrs r'r.PatchTSMixerAttention.forward0s.T9$))#2. 88b8$--8 {{=166|DNNqRST -?)]B^))#2.BBDMMB[[055h?II!QO {{>277AKKAqQ (?(M(M KK , ,.E) %8      % $}}C$,,LL/ %  % ! \"));;;;FFH mmK0 L((r)) r<rrrrrrrrrrr)rFTFN)NNF)r0r1r2r3r4r5floatboolrrrLrMr r tupler.r6r7r8s@r'rrsG  ,0CCC C  C  CC#T)CCD15.2). 0)||0) ,,-0) t+ 0)  $; 0)-.0) u||U\\D00 10)0)r)rc:^\rSrSrSrS\4U4SjjrSrSrU=r $)PatchMixerBlockiczhThis module mixes the patch dimension. Args: config (`PatchTSMixerConfig`): Configuration. r<c>[TU]5 [U5UlURUlUR Ul[ URURUS9UlUR (a#[URURS9Ul UR(a@[URURURUS9Ul[U5Ulgg)Nrr)rrrr<)rrrvr| self_attnrrrWrrrrrAself_attn_headsrself_attn_layer norm_attnrDs r'rPatchMixerBlock.__init__ks )&1 )) ++"**++     :6CUCU`f`r`r sD    #8 .. 00 $D 36:DN r)cUnURU5nUR(aGURup4pVURX4-XV5nUR USS9upURX4XV5nUR SS5nUR U5nUR(aURU5nUR SS5nUR(aURUW-5nX-n U $)zj Args: hidden_state (`torch.Tensor`): Input tensor. Returns: `torch.Tensor`: Transformed tensor. F)rrGr) r|rrrrrHrrrr) r%rrr batch_sizen_varsrWrAhidden_state_reshapedx_attn_rs r'r.PatchMixerBlock.forwards yy. >>7C7I7I 4J $0$8$89Lk$c !,,-BV[,\IF^^J MF$--a3 xx - ??,,\:L$--a3 >>>>,*?@L% r))rrrr|rrr r0r1r2r3r4rrr.r6r7r8s@r'rrcs;1;4!!r)rcV^\rSrSrSrS\4U4SjjrS\R4Sjr Sr U=r $)FeatureMixerBlockizrThis module mixes the hidden feature dimension. Args: config (`PatchTSMixerConfig`): Configuration. r<c>[TU]5 [U5UlURUl[ UR UR US9UlUR(a$[UR UR S9Ul ggr) rrrvr|rrrArrrrDs r'rFeatureMixerBlock.__init__sn )&1  ++"     :6>>\b\j\j kD  r)hiddencUnURU5nURU5nUR(aURU5nX-nU$) Args: hidden (`torch.Tensor` of shape `(batch_size, num_patches, d_model)`): Input tensor to the layer. Returns: `torch.Tensor`: Transformed tensor. )r|rrr)r%rrrs r'r.FeatureMixerBlock.forwardsI6"&! ??&&v.F r)rrKr8s@r'rrs,l1l ellr)rcV^\rSrSrSrS\4U4SjjrS\R4Sjr Sr U=r $)PatchTSMixerLayeriz The `PatchTSMixer` layer that does all three kinds of mixing. Args: config (`PatchTSMixerConfig`): Configuration. r<c>[TU]5 [US9Ul[ US9UlUR UlUR S:Xa[US9Ulgg)Nr< mix_channel) rrr patch_mixerr feature_mixermoderchannel_feature_mixerrDs r'rPatchTSMixerLayer.__init__sR *&9.f=KK ;;- ')MU[)\D & (r)rcURS:XaURU5nURU5nURU5nU$)rr)rrrr)r%rs r'r.PatchTSMixerLayer.forwardsE 99 %//7F!!&)##F+ r))rrrrrKr8s@r'rrs, ]1 ]ellr)rcF^\rSrSrSrS\4U4SjjrSS\4SjjrSr U=r $) PatchTSMixerBlockiz{The main computing framework of the `PatchTSMixer` model. Args: config (`PatchTSMixerConfig`): Configuration. r<c >[TU]5 URn[R"[ U5Vs/sH n[ US9PM sn5Ulgs snfNr)rr num_layersr ModuleListrangermixers)r%r<rrr&s r'rPatchTSMixerBlock.__init__sI && mmuU_O`$aO`!%6f%EO`$ab $asAoutput_hidden_statesc/nUnURH%nU"U5nU(dMURU5 M' U(aXC4$US4$)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%rrr all_hidden_states embeddingmods r'r.PatchTSMixerBlock.forward sR ;;CII##!((3 / /d? "r))r F) r0r1r2r3r4rrrr.r6r7r8s@r'rrs(c1c#$##r)rc>^\rSrSrSrSS\4U4SjjjrSrSrU=r $)PatchTSMixerForPredictionHeadi%zaPrediction Head for Forecasting Args: config (`PatchTSMixerConfig`): Configuration. r<c>[TU]5 URUlURbURR5 [R "UR 5UlUc>[R"URUR-UR5Ul O-URURUR-5Ul [R"SS9Ulg)N start_dim)rrprediction_channel_indicessortr r head_dropout dropout_layerr!rWrAprediction_lengthbase_forecast_blockget_parameter_projectionFlattenflatten)r%r<distribution_outputr&s r'r&PatchTSMixerForPredictionHead.__init__-s *0*K*K'  * * 6  + + 0 0 2ZZ(;(;<  &')yy&2D2Dv~~2UX^XpXp'qD $':'S'S""V^^3(D $zzB/ r)cv^TRU5nTRU5nTRU5n[U[5(a[ SU55nOUR SS5nTR b=[U[5(a[ U4SjU55nU$USTR 4nU$)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# UHoRSS5v M g7f)rrN)rH).0zs r' 8PatchTSMixerForPredictionHead.forward..PsC(Q[[R00(s rrc3D># UHoSTR4v M g7f).N)r)r'r(r%s r'r)r*Vs! [RZQ3(G(G#G!HRZs .)r"rr isinstancerrHrr%hidden_featuresforecasts` r'r.%PatchTSMixerForPredictionHead.forward?s,,7,,_=++O< h & &C(CCH))"b1H  * * 6(E** [RZ [[$C)H)H$HIr))rrr"rr+rr8s@r'rr%s$0100$r)rc>^\rSrSrSrSS\4U4SjjjrSrSrU=r $)PatchTSMixerLinearHeadi]zpLinear head for Classification and Regression. Args: config (`PatchTSMixerConfig`): Configuration. r<c\>[TU]5 URUlURUlURc URnOSnX lUcA[ R"URUR-U-UR5Ul O0URURUR-U-5Ul URc[ R"SS9UlO[ R"SS9Ul[ R"UR 5Ulg)Nrrr)rrhead_aggregation output_rangerWr#r r!rAr num_targets projectionr r!r"rrr)r%r<r# mul_factorr&s r'rPatchTSMixerLinearHead.__init__es  & 7 7"//  " " *++JJ#6  & ii!:!::ZG""DO 2JJ!:!::ZGDO  " " *::3DL::3DLzz&"5"56 r)c0URSS5nURS:XaUSnOIURS:XaURSS9RnOURS:XaUR SS9nUR (aUR U5nUR U5nURU5nURcSURbF[R"U5URSURS - -URS -nU$) 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)`. rruse_last).rmax_poolravg_poolrr) rHr5maxvaluesrir"rr8r#r6rLsigmoid)r%r.s r'r.PatchTSMixerLinearHead.forwards *33B;  J .-g6O  " "j 0-11b19@@O  " "j 0-22r2:O <<"ll?;O,,7///:  $ $ ,43D3D3P o.$2C2CA2FIZIZ[\I]2]^aeararstauu r))r#rr"r5r6r8r+rr8s@r'r2r2]s$71778  r)r2cl^\rSrSr%\\S'SrSrSrSr \ R"5U4Sj5r Sr U=r$) PatchTSMixerPreTrainedModelir<model past_values)timeFc>[TU]U5 [U[5(a<URR S:Xa![ R"URSSS9 gg[U[5(aU[ R"URR5 [ R"URR5 gg)zInitialize weightsr[rg?)rirjN)r _init_weightsr,rOr<r`initnormal_rTr:zeros_rCrones_weight)r%rr&s r'rI)PatchTSMixerPreTrainedModel._init_weightss f% f< = ={{33x? V00sD@  5 6 6 KK((-- . JJv''.. /7r))r0r1r2r3r__annotations__base_model_prefixmain_input_nameinput_modalitiessupports_gradient_checkpointingrLno_gradrIr6r7r8s@r'rDrDs: #O &+# ]]_ 0 0r)rDc:^\rSrSrSrS\4U4SjjrSrSrU=r $)PatchTSMixerPretrainHeadizSPretraining head. Args: config (`PatchTSMixerConfig`): Configuration. r<c>[TU]5 [R"UR5Ul[R "URUR5Ul gr+) rrr rrrr!rA patch_length base_pt_blockrDs r'r!PatchTSMixerPretrainHead.__init__sB ZZ(;(;<YYv~~v7J7JKr)cJURU5nURU5nU$)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)`. )rr[r-s r'r. PatchTSMixerPretrainHead.forwards),,_=%%o6r))r[rrr8s@r'rXrXs!L1L  r)rXr, mask_ratiounmasked_channel_indiceschannel_consistent_masking mask_valuecUS:dUS:a[SUS35eURupVpxURn [USU- -5n U(a*[R "USXyS9n U R SUS5n O[R "XVXyS9n [R"XVXyS9n SU SS2SS2SU 24'[R"U SS9n [R"U SS9n[R"U SUS 9n U RS5R SSSU5n UbSU SS2USS2SS24'URU R5U5nXS 4$) 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] rrz Mask ratio z has to be between 0 and 1.deviceNrr)rindex.r) rkrrer5rLrandrepeatonesargsortgatherrc masked_fillr)r,r_r`rarbr num_channelssequence_length num_featuresrelen_keepnoisemask ids_shuffle ids_restore inputs_masks r'random_maskingrwsA4A~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)num_forecast_mask_patchescP[U[5(aU/nUVs/sHnSPM nnURupgp[R"XgXR S9n /n Sn [ U5n [X5HGupUS::dX:a[SUS35e[Xo-U - 5nU RXU/5 U U- n MI [U SS9n X:aU SSXl- -U SS'OX:aU S SX- -U S S'SnU HunnnUU-nSU UU2S S 2U*S 24'UnM [R"U RS5nU Un U RS 5RSSSU 5n UbSU S S 2US S 2S S 24'URU R5U5nUU S 4$s snf) 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)` rrdrznum_forecast_mask_patches z6 should be greater than 0 and less than total patches.c US$NrGrP)xs r'"forecast_masking..@s!A$r))rrGrNrg)r,r5rrLrVresumziprkrsortedrandpermrcrirmr)r,rxr`rbrforecast_mask_ratiosrrnrorprst_list total_length total_ratiorZratiotemp_lenbatch1 patch_lenbatch2permrvs r'forecast_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 F#cV^\rSrSrSrS\4U4SjjrS\R4Sjr Sr U=r $)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)` r<c>[TU]5 URUlURUlUR UlURUR::a&[ SURSURS35e[URUR5UR- UR -S-UlURUR URS- --nURU- Ul g)NzSequence length (z+) has to be greater than the patch length ()r) rrcontext_lengthrorZ patch_striderkr?rWsequence_start)r%r<new_sequence_lengthr&s r'rPatchTSMixerPatchify.__init__as %44"//"//   4#4#4 4#D$8$8#99deievevdwwxy    4 4d6G6GH4K\K\\aeararruvv"//$2C2CtGWGWZ[G[2\\"225HHr)rFc4URSnX R:wa[SUSURS35eUSS2URS2SS24nUR SUR UR S9nURSS5R5nU$)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)` rzInput sequence length (z%) doesn't match model configuration (rN) dimensionrstepr4) rrorkrunfoldrZrrHr)r%rFrorIs r'r.PatchTSMixerPatchify.forwardrs&++B/ 22 2)/)::_`d`t`t_uuwx Q 3 3 5q89$2C2C$J[J[\!!"b)446 r))rWrZrrorrKr8s@r'rrYs,I1I"5<<r)rcV^\rSrSrSrS\4U4SjjrS\R4Sjr Sr U=r $)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 r<c>>[TU]5 URUlURUlURUlUR UlUR UlURUlUR b[UR 5Ulggr+) rrrandom_mask_ratiora mask_typerxr`rbrrDs r'rPatchTSMixerMasking.__init__s !'!9!9*0*K*K')))/)I)I&(.(G(G% ++  ( ( 4,243P3P,QD ) 5r)rocdURS:Xa8[UURURURUR S9up#OVURS:Xa-[ UURURUR S9up#O[SURS35eUR5nX#4$)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 r[)r,r_r`rarbr/)r,rxr`rbzInvalid mask type .) rrwrr`rarbrrxrkr)r%ro masked_inputrss r'r.PatchTSMixerMasking.forwards >>X %!/"11)-)F)F+/+J+J?? " L$^^z )!1"*.*H*H)-)F)F?? " L$1$..1ACD Dyy{!!r))rarrbrxrr`rKr8s@r'rrs,  R1 R!"5<<!"!"r)rc ^\rSrSrSrS\4U4SjjrS\RS\RS\ \R\R\R44Sjr S r U=r $) 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. r<c>[TU]5 [US5(a UROSUl[US5(a UR OSUl[US5(aUR UlgSUlg)N scaling_dimrkeepdimT minimum_scalegh㈵>)rrhasattrrrrrrDs r'rPatchTSMixerStdScaler.__init__sd )0)G)G6%%Q)0)C)Cv~~ 5[TU]5 [US5(a UROSUl[US5(a UR OSUl[US5(a UR OSUl[US5(aURUlgSUlg)NrrrTr绽|= default_scale)rrrrrrrrrDs r'rPatchTSMixerMeanScaler.__init__s )0)G)G6%%Q)0)C)Cv~~ 5[TU]5 [US5(a UROSUl[US5(aUR UlgSUlg)NrrrT)rrrrrrrDs r'rPatchTSMixerNOPScaler.__init__'sF )0)G)G6%%Q)0)C)Cv~~  r)NrrrYc[R"USS9RURURS9n[R "USS9RURURS9nXU4$)aP Parameters: data (`torch.Tensor` of shape `(batch_size, sequence_length, num_input_channels)`): input for Batch norm calculation Returns: tuple of `torch.Tensor` of shapes (`(batch_size, sequence_length, num_input_channels)`,`(batch_size, 1, num_input_channels)`, `(batch_size, 1, num_input_channels)`) Fr\rr)rLrrirrr)r%rrrrs r'r.PatchTSMixerNOPScaler.forward,sgE:??DHHVZVbVb?ct59>>488UYUaUa>b%r)rr+rr8s@r'rr"seN1N MQ LL 6;llT6I u||U\\5<<7 8  r)rzS Base class for `PatchTSMixerEncoderOutput`, with potential hidden states. ) custom_introcp\rSrSr%SrSr\RS-\S'Sr \ \RS-\S'Sr g)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. Nlast_hidden_staterrP) r0r1r2r3r4rrL FloatTensorrQrrr6rPr)r'rr=s937u((4/659M5**+d29r)rc ~^\rSrSrSrS\4U4Sjjr\\S S\ RS\ S-S\ 4S jj55r S rU=r$) PatchTSMixerEncoderiOz Encoder for PatchTSMixer which inputs patched time-series and outputs patched embeddings. Args: config (`PatchTSMixerConfig`): Configuration. r<c>[TU]U5 [R"URUR 5UlUR(a[US9Ul OSUl [US9Ul UR5 gr) rrr r!rZrApatcherrRrOpositional_encoderrmlp_mixer_encoder post_initrDs r'rPatchTSMixerEncoder.__init__Xsc  yy!4!4fnnE  ) )&DF&SD #&*D #!2&!A r)NrFr rYc UbUOURRnURU5nURbURU5nUR XBS9upV[ XVS9$)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)` r )rr)r<r rrrr)r%rFr rpatchesrrs r'r.PatchTSMixerEncoder.forwardeso.%9$D $++JjJj  ,,{+  " " .--g6G+/+A+A'+A+u((;Ljjr))rrrr+)r0r1r2r3r4rrrrrLrMrrr.r6r7r8s@r'rrOs_ 1 -1!k\\!k#Tk!k # !k!kr)rzG Base class for model's outputs, with potential hidden states. c\rSrSr%SrSr\RS-\S'Sr \ \RS-\S'Sr \RS-\S'Sr \RS-\S'Sr \RS-\S'Sr\RS-\S 'S rg) 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. NrrrorsrrrP)r0r1r2r3r4rrLrrQrrrorsrrr6rPr)r'rrs"37u((4/659M5**+d29,0K""T)0%)D%  d ")$(C  T !(&*E5  t #*r)rz= The PatchTSMixer Model for time-series forecasting. c ^\rSrSrS S\S\4U4Sjjjr\\S S\ RS\ RS-S\S-S \ 4S jj55r S r U=r$)PatchTSMixerModelir< mask_inputc>[TU]U5 [U5Ul[ U5UlUSLa[ U5UlOSUlURS:Xa[U5Ul O@URS:XdURSLa[U5Ul O[U5Ul UR5 g)z} mask_input (bool, *optional*, defaults to `False`): Whether to mask the input using the [`PatchTSMixerMasking`] module. TNrirj)rrrencoderrpatchingrmaskingrrscalerrrr)r%r<rr&s r'rPatchTSMixerModel.__init__s  *62 ,V4  .v6DLDL >>V #08DK ^^u $$(>/7DK/7DK r)NrF observed_maskr rYc UbUOURRnSnUc[R"U5nUR X5upgnUR U5n U n UR bUR U 5upURU US9n [U [5(a[U 6n [U RU RU UUUS9$)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)rrrorsrr)r<r rLrrrrrr,rrrrr) r%rFrr rrsscaled_past_valuesrr patched_x enc_inputencoder_outputs r'r.PatchTSMixerModel.forwards0%9$D $++JjJj   !OOK8M)-[)P&MM"45  << #"ll95OI !5&  ne , ,6GN&,>>(66!   r))rrrrrNN)r0r1r2r3rrrrrrLrMrr.r6r7r8s@r'rrsw 1t2.2,0 5 \\5 ||d*5 #Tk 5 ! 5 5 r)rz> Output type of [`PatchTSMixerForPreTrainingOutput`]. c\rSrSr%SrSr\RS-\S'Sr \RS-\S'Sr \RS-\S'Sr \ \RS-\S'Sr g) 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. Nlossprediction_outputsrrrPr0r1r2r3r4rrLrrQrrrrr6rPr)r'rrd &*D%  d ")37))D0726u((4/659M5**+d29r)rz. `PatchTSMixer` for mask pretraining. c ^\rSrSrS\4U4Sjjr\\S S\RS\RS-S\ S-S\ S \ 4 S jj55r S r U=r$) PatchTSMixerForPretrainingir<c>[TU]U5 [USS9Ul[ US9UlUR UlUR5 g)NT)rr)rrrrErXhead masked_lossrrDs r'r#PatchTSMixerForPretraining.__init__"sD  &v$? ,F; !-- r)NrFrr  return_lossrYc UbUOURRnURSLa[RR SS9nO[RR SS9nUR UUUS9n[U[5(a[U6nURUR5nUSLaU"XR5n OSn URSLaKU bHU RSS9UR-R5URR5S -- n [!U UURUR"S 9$) 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 reductionrirr rrrrrrr)r<r rrLr MSELossrEr,rrrrrorirsrrr) r%rFrr rrr model_outputx_hatloss_vals r'r."PatchTSMixerForPretraining.forward+s<6%9$D $++JjJj    t #88##f#5D88##f#5Dzz '!5" lE * *2LAL ,889 $ E#;#;[TU]U5 URUlURUlURUlURS:XaSUlO`UR n[[[S.nURUR 5nUb U"US9UlO[SUR 35e[U5Ul [UUR S9UlUR!5 g)Nmse student_tnormalnegative_binomialrUnknown distribution output r<r#)rrrrnum_parallel_samplesr#rrr r getrkrrErrr)r%r<rdistribution_output_map output_classr&s r'r"PatchTSMixerForPrediction.__init__s  KK *0*K*K'$*$?$?! ;;% '+D $**C+&%;' # 366v7Q7QRL'+7C+@( #?@Z@Z?[!\]]&v. 1 $ 8 8  r)NrFr future_valuesr rrYc DURS:Xa[R"SS9nO"URS:Xa[nO [ S5eUbUOUR R nURUUUS9n[U[5(a[U6nURUR5n Sn URbUR(ayURRU UR SUR4UR"SUR4S 9n Ub(US La#U"U USUR45n [%U 5n OXR"SUR4-UR SUR4-n UbUS LaU"XSUR45n OUR(aJURRXR UR"S 9n UbUS LaU"X5n [%U 5n O+XR"-UR -n Ub US LaU"X5n URb7UR SUR4n UR"SUR4n OUR n UR"n ['U U URUR(U U S 9$) 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. r-rir r#2Invalid loss function: Allowed values: mse and nllNr .rrT)rrrrrr)rr rr#rkr<r rEr,rrrrrr# distributionrrr)rr)r%rFrr9r rrrry_hatrr=rrs r'r.!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)c4URnU"USUSS9nURRURURUR S9n[ U5Vs/sHoeR5PM nn[R"USS9n[US9$s snf)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)rFr9rr r<rrr) r4r#r=rrrr samplerLstackr)r%rFrr4outputsr=rsampless r'generate"PatchTSMixerForPrediction.generatebs2 $88#'!&  //<<  & &GKKw}}= 388L2MN2MQ&&(2MN++g1-1GDD OsB)r#rrrEr4r)NNNTr+)r0r1r2r3r4rrrrrLrMrrr.rVrrFr6r7r8s@r'r+r+s 1<.2-1,0 k \\k ||d*k ||d* k #Tk k  k  )k k Z ]]_.2-E\\-E||d*-E , -E-Er)r+zK Output type of [`PatchTSMixerForTimeSeriesClassificationOutput`]. c\rSrSr%SrSr\RS-\S'Sr \RS-\S'Sr \RS-\S'Sr \ \RS-\S'Sr g) -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. NrrrrrPrrPr)r'rIrIrr)rIc ^\rSrSrSrS\4U4Sjjr\\S S\ RS\ RS-S\ S-S \ S \ 4 S jj55r S rU=r$)'PatchTSMixerForTimeSeriesClassificationiz `PatchTSMixer` for classification application. Args: config (`PatchTSMixerConfig`): Configuration. Returns: `None`. r<c>[TU]U5 [U5Ul[ US9UlUR S;a$[URURS9Ul OSUl UR5 g)NrrjriTrArW) rrrrEr2rrInjectScalerStatistics4DrArW inject_scalerrDs r'r0PatchTSMixerForTimeSeriesClassification.__init__sh  &v. *   >>2 2 8]c]o]o pD  $D  r)NrF target_valuesr rrYc [RR5nUbUOURRnUR UUS9n[ U[5(a[U6nURb4URURURURS9Ul URUR5nUbUSLa U"X5n OSn [U UURURS9$)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. Nrr<Tr)rLr CrossEntropyLossr<r rEr,rrrPrrrrrIr) r%rFrRr rrrrr>rs r'r./PatchTSMixerForTimeSeriesClassification.forwardsJxx((*%9$D $++JjJj zz !5"  lE * *2LAL    (-1->->.. $$"((.?.L *  ,889  $)<E1HH<$*<<&44   r))rrPrEr)r0r1r2r3r4rrrrrLrMrrIr.r6r7r8s@r'rKrKs  1 .2,0 C \\C ||d*C #Tk C  C  7C C r)rKz= Output type of [`PatchTSMixerForRegressionOutput`]. c\rSrSr%SrSr\RS-\S'Sr \RS-\S'Sr \RS-\S'Sr \ \RS-\S'Sr g) 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. Nrregression_outputsrrrP)r0r1r2r3r4rrLrrQrXrrrr6rPr)r'rWrWrr)rWc^\rSrSrS S\S\S\4U4SjjjrS\RS\RS\R4S jrS r U=r $) rOi&rArW expansionc(>[TU]5 [R"US-X1-5Ul[R"X1-U5Ul[R"SSU-5Ul[R"SU-S5UlX lgr{) rrr r!inverse_trans_expansioninverse_trans_compressionmap_scale_expansionmap_scale_compressionrW)r%rArWrZr&s r'r!InjectScalerStatistics4D.__init__'sr ')yy1i>Q'R$)+93F)P&#%99QI #> %'YYq9}a%@"&r)r,rrcURSS5nURS5nURSSURS5nURSS5nURS5nURSSURS5n[R "XE/SS9nUR U5nURU5n[R "X/SS9nURU5nURU5nU$)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)` rrrr) rHrcrirWrLcatr^r_r\r])r%r,rrristdev concat_statss r'r. InjectScalerStatistics4D.forward0s}}R$~~b!{{1a!1!115B'# Q4#3#3Q7yy$B7 // = 11,? F1r:--f5//7 r))r]r\r_r^rW)rG) r0r1r2r3r5rrLrMr.r6r7r8s@r'rOrO&sM''#'#''ellellr)rOz4 `PatchTSMixer` for regression application. c ^\rSrSrS\4U4Sjjr\\S S\RS\RS-S\ S-S\ S \ 4 S jj55r \R"5S\RS \4S j5rS rU=r$)PatchTSMixerForRegressioniNr<c^>[TU]U5 [U5UlURUlUR UlUR UlURS:XaSUlO^[[[S.nURUR 5nUbU"URS9UlO[SUR 35eURS;a$[URUR S9UlOSUl[%UUR S9UlUR)5 g)Nr-r.rr2rMrNr3)rrrrErr#r4rr r r5r7rkrrOrArWrPr2rr)r%r<r6r7r&s r'r"PatchTSMixerForRegression.__init__Ts  &v. KK #)#=#= $*$?$?! ;;% '+D $,&%;' # 366v7Q7QRL'+7F>2 2 8]c]o]o pD  $D * $ 8 8  r)NrFrRr rrYc \^TRS:Xa[R"SS9nO"TRS:Xa[nO [ S5eUbUOTR R nTRUUS9n[U[5(a[U6nTRb4TRURURURS9Ul TRUR5nUbUS LaTR (a}TR S :Xa)["R$"US :5(a ['S 5eTR R)U5n [U4S jU55nU"X5n [+U 5n O U"X5n OSn [-U UURUR.S9$)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. r-rir r#r;Nrr<Tr1rzDtarget_values cannot be negative for negative_binomial distribution.c3n># UH*oRSTRR5v M, g7f)rN)rr<r7)r'itemr%s r'r)4PatchTSMixerForRegression.forward..s)WQViiDKK,C,CDDQVs25)rrXrr)rr rr#rkr<r rEr,rrrPrrrrr#rLany Exceptionr=r)rWr) r%rFrRr rrrrr>r=rs ` r'r.!PatchTSMixerForRegression.forwardysH 99 ::/D YY% DQR R%9$D $++JjJj zz !5"  lE * *2LAL    (-1->->.. $$"((.?.L *  ,889  $)<''++/BBuyyQ^abQbGcGc#$jkk#77DDUK WQVWW <+H55H.$*<<&44   r)cRURnU"USSS9nURRUR5n[ U5Vs/sHoTR 5PM nn[ R"USS9RSX RR5n[US9$s snf)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)rFrRr rrrrA) r4r#r=rXr rBrLrCrr<r7r)r%rFr4rDr=rrEs r'rF"PatchTSMixerForRegression.generates" $88#!& //<rsQ" $! 7*&B5&UURR:   H %*&BII&,$RYY$N.BII.bbii.-299-n!% II% <<% % << % LL4' % T\ %%'(%:R)BIIR)jCbiiCL* *Z# #L&# &#R5BII5pDRYYDN0/00*ryyD-1', 7% LL7%7%#Tk7%!% 7%  7%|-1 A% LLA%#czA%#TkA% A%J-299-b9""))9"z 0BII 0H3;RYY3;n BII 6   : :  :9k59kx  +k+  +4 Q 3Q  Q h  :{:  :$ F !<F  F R  +k+  +0  // /  // /#u""//##%,,#*5<<*%,,:M*chcoco*0GE ;GET  :K:  :$` .I` F  :k:  :$%ryy%P ^E ;^E  ^EB r)