ó
    ˆŽ¡jKI ã                   ó�  • S r SSKrSSKJr  SSKJr  SSKrSSKJr  SSKJ	r
  SSKJr  SS	KJr  SS
KJr  SSKJr  SSKJrJr  SSKJr  SSKJrJrJr  SSKJrJrJrJ r   SSK!J"r"  \ RF                  " \$5      r%  SoS\RL                  S\RN                  S\RN                  S\RN                  S\RN                  S-  S\(S-  S\(S\\   4S jjr) " S S\RL                  5      r* " S S\RL                  5      r+   SpS\RN                  S \(S!\,S-  S"\-S#\.4
S$ jjr/  SqS\RN                  S%\,\.-  S!\,S-  S#\.4S& jjr0 " S' S(\RL                  5      r1 " S) S*\RL                  5      r2 " S+ S,\RL                  5      r3\ " S- S.\5      5       r4 " S/ S0\RL                  5      r5 " S1 S2\RL                  5      r6 " S3 S4\45      r7\" S5S69\ " S7 S8\5      5       5       r8\" S9S69\ " S: S;\5      5       5       r9\" S<S69\ " S= S>\5      5       5       r:\" S?S69\ " S@ SA\5      5       5       r;\" SBS69\ " SC SD\5      5       5       r<\" SES69\ " SF SG\5      5       5       r=SH\R|                  R~                  SI\RN                  SJ\RN                  4SK jr@SrSL\RN                  SM\RN                  S-  SJ\RN                  4SN jjrA " SO SP\RL                  5      rB " SQ SR\RL                  5      rC " SS ST\RL                  5      rD " SU SV\RL                  5      rE\ " SW SX\45      5       rF " SY SZ\RL                  5      rG\" S[S69 " S\ S]\45      5       rH " S^ S_\RL                  5      rI\" S`S69 " Sa Sb\45      5       rJ\" ScS69 " Sd Se\RL                  5      5       rK\" SfS69 " Sg Sh\45      5       rL " Si Sj\RL                  5      rM\" SkS69 " Sl Sm\45      5       rN/ SnQrOg)szPyTorch PatchTST model.é    N)ÚCallable)Ú	dataclass)Únné   )Úinitialization)ÚACT2CLS)Úis_deepspeed_zero3_enabled)ÚFlashAttentionKwargs)ÚBaseModelOutput)ÚALL_ATTENTION_FUNCTIONSÚPreTrainedModel)ÚUnpack)ÚNegativeBinomialOutputÚNormalOutputÚStudentTOutput)ÚModelOutputÚTransformersKwargsÚauto_docstringÚloggingé   )ÚPatchTSTConfigÚmoduleÚqueryÚkeyÚvalueÚattention_maskÚscalingÚdropoutÚkwargsc                 óŽ  • Uc  UR                  S5      S-  n[        R                  " XR                  SS5      5      U-  nUb  X„-   n[        R
                  R                  USS9n[        R
                  R                  X†U R                  S9n[        R                  " Xƒ5      n	U	R                  SS5      R                  5       n	X˜4$ )Néÿÿÿÿç      à¿é   r   ©Údim)ÚpÚtrainingr   )
ÚsizeÚtorchÚmatmulÚ	transposer   Ú
functionalÚsoftmaxr   r'   Ú
contiguous)
r   r   r   r   r   r   r   r   Úattn_weightsÚattn_outputs
             Ú¼C:\Users\johnn\AppData\Local\Packages\PythonSoftwareFoundation.Python.3.13_qbz5n2kfra8p0\LocalCache\local-packages\Python313\site-packages\transformers/models/patchtst/modeling_patchtst.pyÚeager_attention_forwardr2   '   s±   € ð �Ø—*‘*˜R“. DÑ(ˆô —<’< §}¡}°Q¸Ó':Ó;¸gÑE€LàÑ!Ø#Ñ4ˆä—=‘=×(Ñ(¨¸2Ð(Ð>€LÜ—=‘=×(Ñ(¨È6Ï?É?Ð(Ð[€Lä—,’,˜|Ó3€KØ×'Ñ'¨¨1Ó-×8Ñ8Ó:€KàÐ$Ð$ó    c                   ó  ^ • \ rS rSrSr     SS\S\S\S\S\S	\S
\S-  4U 4S jjjr	   SS\
R                  S\
R                  S-  S\
R                  S-  S\S-  S\\   S\\
R                  \
R                  S-  4   4S jjrSrU =r$ )ÚPatchTSTAttentionéD   z=Multi-headed attention from 'Attention Is All You Need' paperNÚ	embed_dimÚ	num_headsr   Ú
is_decoderÚbiasÚ	is_causalÚconfigc                 óæ  >• [         TU ]  5         Xl        X l        X0l        X-  U l        Xpl        U R
                  U-  U R                  :w  a  [        SU R                   SU S35      eU R
                  S-  U l        X@l	        X`l
        [        R                  " XUS9U l        [        R                  " XUS9U l        [        R                  " XUS9U l        [        R                  " XUS9U l        g )Nz;embed_dim must be divisible by num_heads (got `embed_dim`: z and `num_heads`: ú).r"   ©r:   )ÚsuperÚ__init__r7   r8   r   Úhead_dimr<   Ú
ValueErrorr   r9   r;   r   ÚLinearÚk_projÚv_projÚq_projÚout_proj)	Úselfr7   r8   r   r9   r:   r;   r<   Ú	__class__s	           €r1   rA   ÚPatchTSTAttention.__init__G   sÎ   ø€ ô 	‰ÑÔØ"ŒØ"ŒØŒØ!Ñ.ˆŒØŒà�M‰M˜IÑ%¨$¯.©.Ó8ÜØMÈdÏnÉnÐM]Ø$ Y K¨rð3óð ð —}‘} dÑ*ˆŒØ$ŒØ"Œä—i’i 	¸4Ñ@ˆŒÜ—i’i 	¸4Ñ@ˆŒÜ—i’i 	¸4Ñ@ˆŒÜŸ	š	 )¸TÑBˆ�r3   Úhidden_statesÚkey_value_statesr   Úoutput_attentionsr   Úreturnc                 ó  • USLnUR                   SS n/ UQSPU R                  P7nU R                  U5      R                  U5      R	                  SS5      n	U(       a  UOUn
/ U
R                   SS QSPU R                  P7nU R                  U
5      R                  U5      R	                  SS5      nU R                  U
5      R                  U5      R	                  SS5      n[        R                  " U R                  R                  [        5      nU" U U	UUU4U R                  (       d  SOU R                  U R                  US.UD6u  nnUR                  " / UQSP76 R!                  5       nU R#                  U5      nUU4$ )z#Input shape: Batch x Time x ChannelNr!   r   r#   ç        )r   r   rN   )ÚshaperB   rG   Úviewr+   rE   rF   r   Úget_interfacer<   Ú_attn_implementationr2   r'   r   r   Úreshaper.   rH   )rI   rL   rM   r   rN   r   Úis_cross_attentionÚinput_shapeÚhidden_shapeÚquery_statesÚcurrent_statesÚkv_shapeÚ
key_statesÚvalue_statesÚattention_interfacer0   r/   s                    r1   ÚforwardÚPatchTSTAttention.forwardf   s†  € ð .°TÐ9Ðð $×)Ñ)¨#¨2Ð.ˆà8˜Ð8 bÐ8¨$¯-©-Ñ8ˆð —{‘{ =Ó1×6Ñ6°|ÓD×NÑNÈqÐRSÓTˆæ-?Ñ)À]ˆØB�^×)Ñ)¨#¨2Ð.ÐB°ÐB°D·M±MÑBˆØ—[‘[ Ó0×5Ñ5°hÓ?×IÑIÈ!ÈQÓOˆ
Ø—{‘{ >Ó2×7Ñ7¸ÓA×KÑKÈAÈqÓQˆä(?×(MÒ(MØ�K‰K×,Ñ,Ô.Eó)
Ðñ %8ØØØØØð
%
ð  $Ÿ}Ÿ}‘C°$·,±,Ø—L‘LØ/ñ
%
ð ñ
%
Ñ!ˆ�\ð "×)Ò)Ð;¨;Ð;¸Ò;×FÑFÓHˆØ—m‘m KÓ0ˆà˜LÐ(Ð(r3   )r<   r   r7   rB   r;   r9   rE   r8   rH   rG   r   rF   )rQ   FTFN)NNF)Ú__name__Ú
__module__Ú__qualname__Ú__firstlineno__Ú__doc__ÚintÚfloatÚboolr   rA   r)   ÚTensorr   r
   Útupler`   Ú__static_attributes__Ú__classcell__©rJ   s   @r1   r5   r5   D   sú   ø† ÙGð Ø ØØØ(,ñCàðCð ðCð ð	Cð
 ðCð ðCð ðCð  Ñ%÷Cð CðD 15Ø.2Ø).ñ0)à—|‘|ð0)ð  Ÿ,™,¨Ñ-ð0)ð Ÿ™ tÑ+ð	0)ð
   $™;ð0)ð Ð-Ñ.ð0)ð 
ˆu�|‰|˜UŸ\™\¨DÑ0Ð0Ñ	1÷0)ó 0)r3   r5   c                   óV   ^ • \ rS rSrSrS\4U 4S jjrS\R                  4S jr	Sr
U =r$ )ÚPatchTSTBatchNormé™   zH
Compute batch normalization over the sequence length (time) dimension.
r<   c                 ó~   >• [         TU ]  5         [        R                  " UR                  UR
                  S9U l        g )N©Úeps)r@   rA   r   ÚBatchNorm1dÚd_modelÚnorm_epsÚ	batchnorm©rI   r<   rJ   s     €r1   rA   ÚPatchTSTBatchNorm.__init__ž   s(   ø€ Ü‰ÑÔÜŸš¨¯©¸F¿O¹OÑLˆ�r3   Úinputsc                 ól   • UR                  SS5      nU R                  U5      nUR                  SS5      $ )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   r#   )r+   rx   )rI   r{   Úoutputs      r1   r`   ÚPatchTSTBatchNorm.forward¢   s7   € ð ×!Ñ! ! QÓ'ˆØ—‘ Ó'ˆØ×Ñ  1Ó%Ð%r3   )rx   ©rb   rc   rd   re   rf   r   rA   r)   rj   r`   rl   rm   rn   s   @r1   rp   rp   ™   s+   ø† ñðM˜~÷ Mð
&˜eŸl™l÷ 
&ò 
&r3   rp   r{   Ú
mask_ratioÚunmasked_channel_indicesÚchannel_consistent_maskingÚ
mask_valuec                 ó˜  • US:  d  US:¼  a  [        SU S35      eU R                  u  pVpxU R                  n	[        USU-
  -  5      n
U(       a*  [        R
                  " USXyS9nUR                  SUS5      nO[        R
                  " XVXyS9n[        R                  " XVXyS9nSUSS2SS2SU
24'   [        R                  " USS9n[        R                  " USS9n[        R                  " USUS	9nUR                  S5      R                  SSSU5      nUb  SUSS2USS2SS24'   U R                  UR                  5       U5      nXüS
   4$ )a†  random_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]
r   r   zMask ratio z has to be between 0 and 1.©ÚdeviceNr!   r$   )r%   Úindex©.r   )rC   rR   r†   rg   r)   ÚrandÚrepeatÚonesÚargsortÚgatherÚ	unsqueezeÚmasked_fillri   )r{   r€   r�   r‚   rƒ   Ú
batch_sizeÚnum_channelsÚsequence_lengthÚnum_featuresr†   Úlen_keepÚnoiseÚmaskÚids_shuffleÚids_restoreÚinputs_masks                   r1   Úrandom_maskingrš   ¯   sA  € ð4 �Aƒ~˜ q›Ü˜; z lÐ2MÐNÓOÐOà>D¿l¹lÑ;€J˜oØ�]‰]€Fä�? a¨*¡nÑ5Ó6€Hæ!Ü—
’
˜: q¨/ÑIˆØ—‘˜Q ¨aÓ0‰ô —
’
˜:°_ÑTˆô �:Š:�j°ÑO€DØ€DŠŠAˆy�ˆyˆÑô —-’- ¨2Ñ.€KÜ—-’- °Ñ4€Kä�<Š<˜ "¨KÑ8€DØ�>‰>˜"Ó×$Ñ$ Q¨¨1¨lÓ;€DØÑ+Ø23ˆŠQÐ(ª!ªQÐ.Ñ/à×$Ñ$ T§Y¡Y£[°*Ó=€KØ˜V™Ð$Ð$r3   Únum_forecast_mask_patchesc                 óP  • [        U[        5      (       a  U/nU Vs/ s H  nSPM     nnU R                  u  pgp‰[        R                  " XgX€R
                  S9n
/ nSn[        U5      n[        X5       HG  u  pïUS::  d  Xè:¼  a  [        SU S35      e[        Xo-  U-  5      nUR                  XïU/5        UU-  nMI     [        US S9nXÆ:  a  US   S   Xl-
  -   US   S'   OXÆ:”  a  US	   S   XÆ-
  -   US	   S'   SnU H  u  nnnUU-   nSU
UU2S
S
2U* S
24'   UnM     [        R                  " U
R                  S   5      nU
U   n
U
R                  S	5      R                  SSSU	5      n
Ub  SU
S
S
2US
S
2S
S
24'   U R                  U
R                  5       U5      nUU
S   4$ s  snf )ai  Forecast 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)`
r   r…   r   znum_forecast_mask_patches z6 should be greater than 0 and less than total patches.c                 ó   • U S   $ )Nr#   © )Úxs    r1   Ú<lambda>Ú"forecast_masking.<locals>.<lambda>  s   € ¨!¨Aª$r3   )r   r#   r!   Nrˆ   )Ú
isinstancerg   rR   r)   Úzerosr†   ÚsumÚziprC   ÚappendÚsortedÚrandpermrŽ   rŠ   r�   ri   )r{   r›   r�   rƒ   Ú_Úforecast_mask_ratiosr�   r‘   r’   r“   r–   Út_listÚtotal_lengthÚtotal_ratioÚpatch_lengthÚratioÚtemp_lenÚbatch1Ú	patch_lenÚbatch2Úpermr™   s                         r1   Úforecast_maskingrµ   é   sí  € ô0 Ð+¬S×1Ñ1Ø%>Ð$?Ð!Ù'@ÓAÒ'@ !›AÑ'@ÐÐAà>D¿l¹lÑ;€J˜oÜ�;Š;�z°ÏÉÑW€Dà€FØ€LÜÐ*Ó+€Kä"Ð#<ÖSÑˆØ˜1Ó Ó ?ÜØ,¨\¨NÐ:pÐqóð ô �zÑ)¨KÑ7Ó8ˆØ�‰�|¨HÐ5Ô6Ø˜Ñ Šñ  Tô �F¡Ñ/€FàÓ Ø˜a‘y ‘| zÑ'@ÑAˆˆq‰	�!ŠØ	Ó	"Ø˜r™
 1™¨Ñ)BÑCˆˆr‰
�1‰à€FÛ"(Ñˆ	�1�hØ˜(Ñ"ˆØ./ˆˆV�Fˆ]šA 	˜z™{Ð*Ñ+ØŠñ #)ô
 �>Š>˜$Ÿ*™* Q™-Ó(€DØ�‰:€Dà�>‰>˜"Ó×$Ñ$ Q¨¨1¨lÓ;€DØÑ+Ø23ˆŠQÐ(ª!ªQÐ.Ñ/à×$Ñ$ T§Y¡Y£[°*Ó=€KØ˜˜V™Ð$Ð$ùòO Bs   �F#c                   óV   ^ • \ rS rSrSrS\4U 4S jjrS\R                  4S jr	Sr
U =r$ )ÚPatchTSTPatchifyi-  z£
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                 ó  >• [         TU ]  5         UR                  U l        UR                  U l        UR
                  U l        U R                  U R                  ::  a&  [        SU R                   SU R                   S35      e[        U R                  U R                  5      U R                  -
  U R
                  -  S-   U l        U R                  U R
                  U R                  S-
  -  -   nU R                  U-
  U l	        g )NzSequence length (z+) has to be greater than the patch length (Ú)r   )
r@   rA   Úcontext_lengthr’   r®   Úpatch_striderC   ÚmaxÚnum_patchesÚsequence_start)rI   r<   Únew_sequence_lengthrJ   s      €r1   rA   ÚPatchTSTPatchify.__init__5  sò   ø€ Ü‰ÑÔà%×4Ñ4ˆÔØ"×/Ñ/ˆÔØ"×/Ñ/ˆÔà×Ñ 4×#4Ñ#4Ó4ÜØ# D×$8Ñ$8Ð#9Ð9dÐei×evÑevÐdwÐwxÐyóð ô
   × 4Ñ 4°d×6GÑ6GÓHÈ4×K\ÑK\Ñ\Ðae×arÑarÑrÐuvÑvˆÔØ"×/Ñ/°$×2CÑ2CÀt×GWÑGWÐZ[ÑG[Ñ2\Ñ\ÐØ"×2Ñ2Ð5HÑHˆÕr3   Úpast_valuesc                 ó4  • UR                   S   nX R                  :w  a  [        SU SU R                   S35      eUSS2U R                  S2SS24   nUR	                  SU R
                  U R                  S9nUR                  SS5      R                  5       nU$ )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)`
éþÿÿÿzInput sequence length (z%) doesn't match model configuration (r>   N)Ú	dimensionr(   Ústepéýÿÿÿ)	rR   r’   rC   r¾   Úunfoldr®   r»   r+   r.   )rI   rÁ   r’   r}   s       r1   r`   ÚPatchTSTPatchify.forwardF  s¦   € ð &×+Ñ+¨BÑ/ˆØ×2Ñ2Ó2ÜØ)¨/Ð):Ð:_Ð`d×`tÑ`tÐ_uÐuwÐxóð ð šQ × 3Ñ 3Ñ 5²qÐ8Ñ9ˆà—‘¨°$×2CÑ2CÈ$×J[ÑJ[�Ð\ˆà×!Ñ! " bÓ)×4Ñ4Ó6ˆØˆr3   )r½   r®   r»   r’   r¾   r   rn   s   @r1   r·   r·   -  s+   ø† ñðI˜~÷ Ið" 5§<¡<÷ ò r3   r·   c                   óV   ^ • \ rS rSrSrS\4U 4S jjrS\R                  4S jr	Sr
U =r$ )ÚPatchTSTMaskingi]  al  
Class to perform random or forecast masking.

Parameters:
    config (`PatchTSTConfig`): 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                 ó>  >• [         TU ]  5         UR                  U l        UR                  U l        UR                  U l        UR
                  U l        UR                  U l        UR                  U l        U R                  b  [        U R                  5      U l        g g ©N)	r@   rA   Úrandom_mask_ratior‚   Ú	mask_typer›   r�   rƒ   r§   ry   s     €r1   rA   ÚPatchTSTMasking.__init__j  s„   ø€ Ü‰ÑÔØ!'×!9Ñ!9ˆÔØ*0×*KÑ*KˆÔ'Ø×)Ñ)ˆŒØ)/×)IÑ)IˆÔ&Ø(.×(GÑ(GˆÔ%Ø ×+Ñ+ˆŒØ×(Ñ(Ñ4Ü,2°4×3PÑ3PÓ,QˆDÕ)ð 5r3   Úpatch_inputc                 ód  • U R                   S:X  a8  [        UU R                  U R                  U R                  U R
                  S9u  p#OVU R                   S:X  a-  [        UU R                  U R                  U R
                  S9u  p#O[        SU R                    S35      eUR                  5       nX#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

Úrandom)r{   r€   r�   r‚   rƒ   Úforecast)r{   r›   r�   rƒ   zInvalid mask type Ú.)
rÎ   rš   rÍ   r�   r‚   rƒ   rµ   r›   rC   ri   )rI   rÐ   Úmasked_inputr–   s       r1   r`   ÚPatchTSTMasking.forwardu  s¯   € ð �>‰>˜XÓ%Ü!/Ø"Ø×1Ñ1Ø)-×)FÑ)FØ+/×+JÑ+JØŸ?™?ñ"ÑˆL˜$ð �^‰^˜zÓ)Ü!1Ø"Ø*.×*HÑ*HØ)-×)FÑ)FØŸ?™?ñ	"ÑˆL˜$ô Ð1°$·.±.Ð1AÀÐCÓDÐDð �y‰y‹{ˆØÐ!Ð!r3   )r‚   rÎ   rƒ   r›   rÍ   r�   r   rn   s   @r1   rÊ   rÊ   ]  s+   ø† ñ
ð	R˜~÷ 	Rð!" 5§<¡<÷ !"ò !"r3   rÊ   c                   ód   ^ • \ rS rSrSrS\4U 4S jjrS
S\R                  S\	S-  4S jjr
S	rU =r$ )ÚPatchTSTEncoderLayeri™  z
PatchTST encoder layer
r<   c                 ó(  >• [         TU ]  5         UR                  U l        [        UR                  UR
                  UR                  US9U l        UR                  S:”  a   [        R                  " UR                  5      O[        R                  " 5       U l        UR                  S:X  a  [        U5      U l        OWUR                  S:X  a/  [        R                   " UR                  UR"                  S9U l        O[%        UR                   S35      eU R                  (       aÂ  UR                  S:”  a   [        R                  " UR                  5      O[        R                  " 5       U l        UR                  S:X  a  [        U5      U l        OWUR                  S:X  a/  [        R                   " UR                  UR"                  S9U l        O[%        UR                   S35      e[        R*                  " [        R,                  " UR                  UR.                  UR0                  S9[2        UR4                     " 5       UR6                  S:”  a   [        R                  " UR6                  5      O[        R                  " 5       [        R,                  " UR.                  UR                  UR0                  S95      U l        UR                  S:”  a   [        R                  " UR                  5      O[        R                  " 5       U l        UR                  S:X  a  [        U5      U l        OWUR                  S:X  a/  [        R                   " UR                  UR"                  S9U l        O[%        UR                   S35      eUR>                  U l        g )N)r7   r8   r   r<   r   rx   Ú	layernormrs   z$ is not a supported norm layer type.r?   ) r@   rA   Úchannel_attentionr5   rv   Únum_attention_headsÚattention_dropoutÚ	self_attnÚpath_dropoutr   ÚDropoutÚIdentityÚdropout_path1Ú	norm_typerp   Únorm_sublayer1Ú	LayerNormrw   rC   Údropout_path2Únorm_sublayer2Ú
SequentialrD   Úffn_dimr:   r   Úactivation_functionÚ
ff_dropoutÚffÚdropout_path3Únorm_sublayer3Úpre_normry   s     €r1   rA   ÚPatchTSTEncoderLayer.__init__ž  s‘  ø€ Ü‰ÑÔà!'×!9Ñ!9ˆÔä*Ø—n‘nØ×0Ñ0Ø×,Ñ,Øñ	
ˆŒð AG×@SÑ@SÐVWÓ@WœRŸZšZ¨×(;Ñ(;Ô<Ô]_×]hÒ]hÓ]jˆÔØ×Ñ˜{Ó*Ü"3°FÓ";ˆDÕØ×Ñ Ó,Ü"$§,¢,¨v¯~©~À6Ç?Á?Ñ"SˆDÕä × 0Ñ 0Ð1Ð1UÐVÓWÐWð ×!×!ØDJ×DWÑDWÐZ[ÓD[¤§¢¨F×,?Ñ,?Ô!@Ôac×alÒalÓanˆDÔØ×Ñ ;Ó.Ü&7¸Ó&?�Õ#Ø×!Ñ! [Ó0Ü&(§l¢l°6·>±>ÀvÇÁÑ&W�Õ#ä  F×$4Ñ$4Ð#5Ð5YÐ!ZÓ[Ð[ô —-’-Ü�IŠI�f—n‘n f§n¡n¸6¿;¹;ÑGÜ�F×.Ñ.Ò/Ó1Ø-3×->Ñ->ÀÓ-BŒB�JŠJ�v×(Ñ(Ô)ÌÏÊËÜ�IŠI�f—n‘n f§n¡n¸6¿;¹;ÑGó	
ˆŒð AG×@SÑ@SÐVWÓ@WœRŸZšZ¨×(;Ñ(;Ô<Ô]_×]hÒ]hÓ]jˆÔØ×Ñ˜{Ó*Ü"3°FÓ";ˆDÕØ×Ñ Ó,Ü"$§,¢,¨v¯~©~À6Ç?Á?Ñ"SˆDÕä × 0Ñ 0Ð1Ð1UÐVÓWÐWàŸ™ˆ�r3   NÚhidden_staterN   c                 ó¾  • UR                   u  p4pVUR                  X4-  XV5      nU R                  (       a5  U R                  U R	                  U5      US9u  pxXR                  U5      -   nO3U R                  XS9u  pxU R	                  XR                  U5      -   5      nUR                  X4XV5      nU R                  (       aß  UR                  SS5      R                  5       nUR                  X5-  XF5      nU R                  (       a5  U R                  U R                  U5      US9u  pyXR                  U5      -   nO3U R                  XS9u  pyU R                  XR                  U5      -   5      nUR                  X5XF5      nUR                  SS5      R                  5       nUR                  X4-  XV5      nU R                  (       a2  XR                  U R                  U R                  U5      5      5      -   nO1U R                  XR                  U R                  U5      5      -   5      nUR                  X4XV5      nU4n
U(       a  X R                  (       a  UW	4OU4-  n
U
$ )ao  
Parameters:
    hidden_state (`torch.Tensor` of shape `(batch_size, num_channels, sequence_length, d_model)`, *required*):
        Past values of the time series
    output_attentions (`bool`, *optional*):
        Whether or not to return the output attention of all layers
Return:
    `torch.Tensor` of shape `(batch_size, num_channels, sequence_length, d_model)`

)rL   rN   r#   r   )rR   rS   rï   rÞ   rä   râ   rV   rÛ   r+   r.   rç   ræ   rí   rì   rî   )rI   rñ   rN   r�   Únum_input_channelsr’   rv   r0   r/   Úchannel_attn_weightsÚoutputss              r1   r`   ÚPatchTSTEncoderLayer.forwardÐ  sY  € ð DP×CUÑCUÑ@ˆ
¨ð $×(Ñ(¨Ñ)HÈ/Ócˆà�=�=à(,¯©Ø"×1Ñ1°,Ó?ÐSdð )7ð )Ñ%ˆKð (×*<Ñ*<¸[Ó*IÑI‰Lð )-¯©À\¨Ð(wÑ%ˆKà×.Ñ.¨|×>PÑ>PÐQ\Ó>]Ñ/]Ó^ˆLð $×+Ñ+¨JÈOÓeˆð ×!×!à'×1Ñ1°!°QÓ7×BÑBÓDˆLà'×,Ñ,¨ZÑ-IÐK]ÓgˆLØ�}�}à48·N±NØ"&×"5Ñ"5°lÓ"CÐWhð 5Cð 5Ñ1�ð  ,×.@Ñ.@ÀÓ.MÑM‘ð 59·N±NØ".ð 5Cð 5Ñ1�ð  $×2Ñ2°<×BTÑBTÐU`ÓBaÑ3aÓb�ð (×/Ñ/°
ÐM_ÓiˆLà'×1Ñ1°!°QÓ7×BÑBÓDˆLð $×(Ñ(¨Ñ)HÈ/ÓcˆØ�=�=ð (×*<Ñ*<¸T¿W¹WÀT×EXÑEXÐYeÓEfÓ=gÓ*hÑh‰Lð  ×.Ñ.¨|×>PÑ>PÐQU×QXÑQXÐYeÓQfÓ>gÑ/gÓhˆLð $×+Ñ+¨JÈOÓeˆà�/ˆÞØ×?U×?U˜Ð&:Ñ;Ð\hÐ[jÑjˆGàˆr3   )
rÛ   râ   ræ   rí   rì   rä   rç   rî   rï   rÞ   rÌ   )rb   rc   rd   re   rf   r   rA   r)   rj   ri   r`   rl   rm   rn   s   @r1   rØ   rØ   ™  s9   ø† ñð0(˜~÷ 0(ñdO E§L¡Lð OÀTÈDÁ[÷ Oó Or3   rØ   c                   óž   ^ • \ rS rSr% \\S'   SrSrSrSr	Sr
SrSr\R                  " 5       S\R                   4U 4S	 jj5       rSS
 jrSrU =r$ )ÚPatchTSTPreTrainedModeli"  r<   ÚmodelrÁ   )ÚtimeFTr   c                 ó6  >• [         TU ]  U5        [        U[        5      (       Gab  [	        U R
                  R                  U R
                  R                  5      U R
                  R                  -
  U R
                  R                  -  S-   nU R
                  R                  (       a$  [        R                  " UR                  SS9  US-  nUR                  U R
                  U5      n[        5       (       aq  SSKnUR                   R#                  UR$                  SS9   UR$                  R'                  5       S:”  a!  [        R(                  " UR$                  U5        SSS5        g[        R(                  " UR$                  U5        gg! , (       d  f       g= f)z
Initialize weights
r   g{®Gáz”?)Ústdr   N)Úmodifier_rank)r@   Ú_init_weightsr¢   ÚPatchTSTPositionalEncodingr¼   r<   rº   r®   r»   Úuse_cls_tokenÚinitÚnormal_Ú	cls_tokenÚ_init_per	   Ú	deepspeedÚzeroÚGatheredParametersÚposition_encÚnumelÚcopy_)rI   r   r½   r  r  rJ   s        €r1   rþ   Ú%PatchTSTPreTrainedModel._init_weights-  s/  ø€ ô
 	‰Ñ˜fÔ%Ü�fÔ8×9Ò9ô �D—K‘K×.Ñ.°·±×0HÑ0HÓIÈDÏKÉK×LdÑLdÑdØ—‘×)Ñ)ñ*à,-ñ.ˆKð �{‰{×(×(Ü—’˜V×-Ñ-°4Ò8Ø˜qÑ �à!Ÿ?™?¨4¯;©;¸ÓDˆLÜ)×+Ñ+Û à—^‘^×6Ñ6°v×7JÑ7JÐZ^Ð6Ò_Ø×*Ñ*×0Ñ0Ó2°QÓ6ÜŸ
š
 6×#6Ñ#6¸ÔE÷ `Ð_ô —
’
˜6×.Ñ.°Õ=ð% :÷ `Õ_ús   ÄA F
Æ

Fc                 ó<   • [        U[        5      (       a  X!l        g g rÌ   )r¢   ÚPatchTSTEncoderÚgradient_checkpointing)rI   r   r   s      r1   Ú_set_gradient_checkpointingÚ3PatchTSTPreTrainedModel._set_gradient_checkpointingG  s   € Ü�fœ×0Ñ0Ø,1Õ)ð 1r3   rž   )F)rb   rc   rd   re   r   Ú__annotations__Úbase_model_prefixÚmain_input_nameÚinput_modalitiesÚsupports_gradient_checkpointingÚ_supports_flash_attnÚ_supports_sdpaÚ_supports_flex_attnr)   Úno_gradr   ÚModulerþ   r  rl   rm   rn   s   @r1   rø   rø   "  s^   ø‡ àÓØÐØ#€OØ ÐØ&+Ð#ØÐØ€NØÐà
‡]‚]ƒ_ð> B§I¡Iö >ó ð>÷22ò 2r3   rø   c                   óR   ^ • \ rS rSrS\4U 4S jjrS\R                  4S jrSr	U =r
$ )ÚPatchTSTEmbeddingiL  r<   c                 óÞ  >• [         TU ]  5         UR                  U l        UR                  U l        U R                  (       a1  [        R
                  " UR                  UR                  5      U l        g [        R                  " 5       U l        [        UR                  5       HG  nU R                  R                  [        R
                  " UR                  UR                  5      5        MI     g rÌ   )r@   rA   ró   Úshare_embeddingr   rD   r®   rv   Úinput_embeddingÚ
ModuleListÚranger¦   )rI   r<   r©   rJ   s      €r1   rA   ÚPatchTSTEmbedding.__init__M  sœ   ø€ Ü‰ÑÔØ"(×";Ñ";ˆÔØ%×5Ñ5ˆÔà××Ü#%§9¢9¨V×-@Ñ-@À&Ç.Á.Ó#QˆDÕ ä#%§=¢=£?ˆDÔ Ü˜6×4Ñ4Ö5�Ø×$Ñ$×+Ñ+¬B¯IªI°f×6IÑ6IÈ6Ï>É>Ó,ZÖ[ò 6r3   rÐ   c                 ój  • UR                   S   nX R                  :w  a  [        SU R                   SU S35      eU R                  (       a  U R	                  U5      nU$ [        U5       Vs/ s H$  o@R                  U   " USS2USS2SS24   5      PM&     nn[        R                  " USS9nU$ s  snf )zõ
Parameters:
    patch_input (`torch.Tensor` of shape `(batch_size, num_channels, num_patches, patch_length)`, *required*):
        Patch input for embedding
return:
    `torch.Tensor` of shape `(batch_size, num_channels, num_patches, d_model)`
r   z&The defined number of input channels (zQ) in the config has to be the same as the number of channels in the batch input (r¹   Nr$   )rR   ró   rC   r  r  r!  r)   Ústack)rI   rÐ   ró   Ú
embeddingsÚis        r1   r`   ÚPatchTSTEmbedding.forwardY  sÌ   € ð )×.Ñ.¨qÑ1ÐØ×!8Ñ!8Ó8ÜØ8¸×9PÑ9PÐ8Qð RTØTfÐSgÐghðjóð ð ××Ø×-Ñ-¨kÓ:ˆJð Ðô UZÐZlÔTmÓnÒTmÈq×.Ñ.¨qÒ1°+ºaÀÂAÂq¸jÑ2IÖJÑTmˆJÐnÜŸš Z°QÑ7ˆJØÐùò os   Á,+B0)r  ró   r  ©rb   rc   rd   re   r   rA   r)   rj   r`   rl   rm   rn   s   @r1   r  r  L  s&   ø† ð
\˜~÷ 
\ð 5§<¡<÷ ò r3   r  c                   óŽ   ^ • \ rS rSrSrS\S\4U 4S jjr\S\S\S\	R                  4S j5       rS\R                  4S	 jrS
rU =r$ )rÿ   ip  z
Class for positional encoding
r<   r½   c                 óÖ  >• [         TU ]  5         UR                  U l        UR                  U l        UR                  (       aA  [        R
                  " [        R                  " SSSUR                  5      5      U l	        US-  nU R                  X5      U l        UR                  S:”  a&  [        R                  " UR                  5      U l        g [        R                  " 5       U l        g )Nr   r   )r@   rA   r   ró   r   Ú	Parameterr)   r£   rv   r  r  r  Úpositional_dropoutrà   rá   ©rI   r<   r½   rJ   s      €r1   rA   Ú#PatchTSTPositionalEncoding.__init__u  s¯   ø€ Ü‰ÑÔØ#×1Ñ1ˆÔØ"(×";Ñ";ˆÔØ××äŸ\š\¬%¯+ª+°a¸¸A¸v¿~¹~Ó*NÓOˆDŒNØ˜1ÑˆKà ŸM™M¨&Ó>ˆÔð 6<×5NÑ5NÐQRÓ5RŒB�JŠJ�v×0Ñ0Ó1ð 	ÕÜXZ×XcÒXcÓXeð 	Õr3   rO   c                 ó$  • U R                   S:X  a5  [        R                  " [        R                  " XR
                  5      SS9nU$ U R                   S:X  Ga#  [        R                  " XR
                  5      n[        R                  " SU5      R                  S5      n[        R                  " [        R                  " SU R
                  S5      [        R                  " S5      U R
                  -  * -  5      n[        R                  " X4-  5      US S 2SS S24'   [        R                  " X4-  5      US S 2SS S24'   X"R                  5       -
  nX"R                  5       S	-  -  n[        R                  " US
S9nU$ [!        U R                    S35      e)NrÒ   T©Úrequires_gradÚsincosr   r   r#   g     ˆÃ@é
   FzN is not a valid positional encoder. Available types are 'random' and 'sincos'.)Úpositional_encoding_typer   r+  r)   Úrandnrv   r£   ÚarangerŽ   ÚexpÚmathÚlogÚsinÚcosÚmeanrü   rC   )r<   r½   r  ÚpositionÚdiv_terms        r1   r  Ú#PatchTSTPositionalEncoding._init_pe„  sX  € ð ×*Ñ*¨hÓ6ÜŸ<š<¬¯ª°KÇÁÓ(PÐ`dÑeˆLð Ðð ×,Ñ,°Ô8Ü Ÿ;š; {·N±NÓCˆLÜ—|’| A {Ó3×=Ñ=¸aÓ@ˆHÜ—y’y¤§¢¨a°·±ÀÓ!CÌÏÊÐQXÓHYÐ\b×\jÑ\jÑHjÐFkÑ!kÓlˆHÜ$)§I¢I¨hÑ.AÓ$BˆLš˜A˜D˜q˜D˜Ñ!Ü$)§I¢I¨hÑ.AÓ$BˆLš˜A˜D˜q˜D˜Ñ!Ø'×*;Ñ*;Ó*=Ñ=ˆLØ'×+;Ñ+;Ó+=ÀÑ+BÑCˆLÜŸ<š<¨ÀEÑJˆLð
 Ðô Ø×2Ñ2Ð3ð  4Bð  Cóð r3   rÐ   c                 óx  • U R                   (       a‹  U R                  XR                  SS 2S S 24   -   5      nU R                  U R                  S S2S S 24   -   nUR	                  UR
                  S   U R                  SS5      n[        R                  " X14SS9nU$ U R                  XR                  -   5      nU$ )Nr   r   r!   r#   r$   )	r   r,  r  r  ÚexpandrR   ró   r)   Úcat)rI   rÐ   r  Ú
cls_tokensrñ   s        r1   r`   Ú"PatchTSTPositionalEncoding.forward˜  s¹   € Ø××à×1Ñ1°+×@QÑ@QÐRSÑRTÒVWÐRWÑ@XÑ2XÓYˆKàŸ™¨×):Ñ):¸2¸A¸2ºq¸5Ñ)AÑAˆIà"×)Ñ)¨+×*;Ñ*;¸AÑ*>À×@WÑ@WÐY[Ð]_Ó`ˆJä Ÿ9š9 jÐ%>ÀAÑFˆLð Ðð  ×2Ñ2°;×ARÑARÑ3RÓSˆLØÐr3   )r  ró   r  r,  r   )rb   rc   rd   re   rf   r   rg   rA   Ústaticmethodr   r+  r  r)   rj   r`   rl   rm   rn   s   @r1   rÿ   rÿ   p  s]   ø† ñð
˜~ð 
¸C÷ 
ð ð˜ð °cð ¸b¿l¹ló ó ðð& 5§<¡<÷ ò r3   rÿ   c            	       óz   ^ • \ rS rSrSrS\S\4U 4S jjr  SS\R                  S\
S-  S	\
S-  S
\4S jjrSrU =r$ )r  i¨  z
PatchTST Encoder
r<   r½   c                 ó,  >• [         TU ]  U5        SU l        [        U5      U l        [        X5      U l        [        R                  " [        UR                  5       Vs/ s H  n[        U5      PM     sn5      U l        U R                  5         g s  snf )NF)r@   rA   r  r  Úembedderrÿ   Úpositional_encoderr   r   r!  Únum_hidden_layersrØ   ÚlayersÚ	post_init)rI   r<   r½   r&  rJ   s       €r1   rA   ÚPatchTSTEncoder.__init__­  sx   ø€ Ü‰Ñ˜Ô Ø&+ˆÔ#ô *¨&Ó1ˆŒä"<¸VÓ"QˆÔä—m’mÌ5ÐQW×QiÑQiÔKjÓ$kÒKjÀaÔ%9¸&Ö%AÑKjÑ$kÓlˆŒð 	�‰Õùò %ls   ÁBNrÐ   Úoutput_hidden_statesrN   rO   c                 óh  • Ub  UOU R                   R                  nUb  UOU R                   R                  nU R                  U5      nU R	                  U5      nU(       a  SOSnU(       a  SOSnU R
                   H+  nU(       a  Xe4-   nU" XSS9n	U	S   nU(       d  M#  XyS   4-   nM-     [        XVUS9$ )ar  
Parameters:
    patch_input (`torch.Tensor` of shape `(batch_size, num_channels, num_patches, patch_length)`, *required*):
        Past values of the time series
    output_hidden_states (bool, optional): Indicates if hidden states should be outputted.
    output_attentions (bool, optional): Indicates if attentions should be outputted.

return:
    `BaseModelOutput`
Nrž   )rñ   rN   r   r   )Úlast_hidden_staterL   Ú
attentions)r<   rN   rN  rH  rI  rK  r   )
rI   rÐ   rN  rN   r   rñ   Úencoder_statesÚall_attentionsÚencoder_layerÚlayer_outputss
             r1   r`   ÚPatchTSTEncoder.forward»  sÃ   € ð" 2CÑ1NÑ-ÐTX×T_ÑT_×TqÑTqÐà$8Ñ$DÑ È$Ï+É+×JjÑJjð 	ð
 —m‘m KÓ0ˆà×.Ñ.¨{Ó;ˆæ3™¸ˆÞ0™°dˆØ!Ÿ[œ[ˆMÞ#Ø!/°/Ñ!A�á)°|ÑiˆMð )¨Ñ+ˆLç Ð Ø!/ÀÑ3CÐ2EÑ!E’ñ )ô °ÐhvÑwÐwr3   )rH  r  rK  rI  ©NN)rb   rc   rd   re   rf   r   rg   rA   r)   rj   ri   r   r`   rl   rm   rn   s   @r1   r  r  ¨  se   ø† ñð˜~ð ¸C÷ ð" -1Ø)-ñ	)xà—\‘\ð)xð # T™kð)xð   $™;ð	)xð 
÷)xó )xr3   r  zG
    Base class for model's outputs, with potential hidden states.
    )Úcustom_introc                   ó>  • \ rS rSr% SrSr\R                  S-  \S'   Sr	\
\R                     S-  \S'   Sr\
\R                     S-  \S'   Sr\R                  S-  \S'   Sr\R                  S-  \S'   Sr\R                  S-  \S	'   Sr\R                  S-  \S
'   Srg)ÚPatchTSTModelOutputiç  a  
last_hidden_state (`torch.FloatTensor` of shape `(batch_size, num_channels, num_patches, patch_length)`):
    Sequence of hidden-states at the output of the last layer of the model.
hidden_states (`tuple(torch.FloatTensor)`, *optional*, returned when `output_hidden_states=True` is passed or when `config.output_hidden_states=True`):
    Tuple of `torch.FloatTensor` (one for the output of the embeddings, if the model has an embedding layer, +
    one for the output of each layer) of shape `(batch_size, num_channels, height, width)`. Hidden-states of
    the model at the output of each layer plus the optional initial embedding outputs.
mask (`torch.FloatTensor` of shape `(batch_size, num_channels, num_patches)`, *optional*):
    Bool masked tensor indicating which patches are masked
loc (`torch.FloatTensor` of shape `(batch_size, 1, num_channels)`, *optional*):
    Mean of the input data (batch_size, sequence_length, num_channels) over the sequence_length
scale (`torch.FloatTensor` of shape `(batch_size, 1, num_channels)`, *optional*):
    Std of the input data (batch_size, sequence_length, num_channels) over the sequence_length
patch_input (`torch.FloatTensor` of shape `(batch_size, num_channels, num_patches, patch_length)`):
    Patched input to the Transformer
NrP  rL   rQ  r–   ÚlocÚscalerÐ   rž   )rb   rc   rd   re   rf   rP  r)   ÚFloatTensorr  rL   rk   rQ  r–   r[  r\  rÐ   rl   rž   r3   r1   rZ  rZ  ç  s§   ‡ ñð" 37Ð�u×(Ñ(¨4Ñ/Ó6Ø59€M�5˜×*Ñ*Ñ+¨dÑ2Ó9Ø26€J��e×'Ñ'Ñ(¨4Ñ/Ó6Ø%)€Dˆ%×
Ñ
˜dÑ
"Ó)Ø$(€Cˆ×	Ñ	˜TÑ	!Ó(Ø&*€Eˆ5×Ñ˜tÑ#Ó*Ø,0€K�×"Ñ" TÑ)Ö0r3   rZ  z4
    Output type of [`PatchTSTForPretraining`].
    c                   óÆ   • \ rS rSr% SrSr\R                  S-  \S'   Sr	\R                  S-  \S'   Sr
\\R                     S-  \S'   Sr\\R                     S-  \S'   Srg)	ÚPatchTSTForPretrainingOutputi  a
  
loss (*optional*, returned when `labels` is provided, `torch.FloatTensor` of shape `(1,)`):
    MSE loss.
prediction_output (`torch.FloatTensor` of shape `(batch_size, sequence_length, config.vocab_size)`):
    Prediction outputs of the time series modeling heads.
NÚlossÚprediction_outputrL   rQ  rž   )rb   rc   rd   re   rf   r`  r)   r]  r  ra  rL   rk   rQ  rl   rž   r3   r1   r_  r_    sh   ‡ ñð &*€Dˆ%×
Ñ
˜dÑ
"Ó)Ø26Ð�u×(Ñ(¨4Ñ/Ó6Ø59€M�5˜×*Ñ*Ñ+¨dÑ2Ó9Ø26€J��e×'Ñ'Ñ(¨4Ñ/Ö6r3   r_  z3
    Output type of [`PatchTSTForRegression`].
    c                   óÆ   • \ rS rSr% SrSr\R                  S-  \S'   Sr	\R                  S-  \S'   Sr
\\R                     S-  \S'   Sr\\R                     S-  \S'   Srg)	ÚPatchTSTForRegressionOutputi  zô
loss (*optional*, returned when `labels` is provided, `torch.FloatTensor` of shape `(1,)`):
    MSE loss.
regression_outputs (`torch.FloatTensor` of shape `(batch_size, num_targets)`):
    Regression outputs of the time series modeling heads.
Nr`  Úregression_outputsrL   rQ  rž   )rb   rc   rd   re   rf   r`  r)   r]  r  rd  rL   rk   rQ  rl   rž   r3   r1   rc  rc    sh   ‡ ñð &*€Dˆ%×
Ñ
˜dÑ
"Ó)Ø37Ð˜×)Ñ)¨DÑ0Ó7Ø59€M�5˜×*Ñ*Ñ+¨dÑ2Ó9Ø26€J��e×'Ñ'Ñ(¨4Ñ/Ö6r3   rc  z3
    Output type of [`PatchTSTForPrediction`].
    c                   ó  • \ rS rSr% SrSr\R                  S-  \S'   Sr	\R                  S-  \S'   Sr
\\R                     S-  \S'   Sr\\R                     S-  \S'   Sr\R                  S-  \S'   Sr\R                  S-  \S	'   S
rg)ÚPatchTSTForPredictionOutputi0  aé  
loss (*optional*, returned when `labels` is provided, `torch.FloatTensor` of shape `(1,)`):
    MSE loss.
prediction_outputs (`torch.FloatTensor` of shape `(batch_size, prediction_length, -1)`):
    Prediction outputs of the time series modeling heads.
attentions (`tuple(torch.FloatTensor)`, *optional*, returned when `output_attentions=True` is passed or when `config.output_attentions=True`):
    Tuple of `torch.FloatTensor` (one for each layer) of shape `(batch_size, num_heads, sequence_length,
    sequence_length)`.

    Attentions weights after the attention softmax, used to compute the weighted average in the self-attention
    heads.
loc: (`torch.FloatTensor` of shape `(batch_size, 1, num_channels)`, *optional*)
    Mean of the input data (batch_size, sequence_length, num_channels) over the sequence_length
scale: (`torch.FloatTensor` of shape `(batch_size, 1, num_channels)`, *optional*)
    Std of the input data (batch_size, sequence_length, num_channels) over the sequence_length
Nr`  Úprediction_outputsrL   rQ  r[  r\  rž   )rb   rc   rd   re   rf   r`  r)   r]  r  rg  rL   rk   rQ  r[  r\  rl   rž   r3   r1   rf  rf  0  s’   ‡ ñð" &*€Dˆ%×
Ñ
˜dÑ
"Ó)Ø37Ð˜×)Ñ)¨DÑ0Ó7Ø59€M�5˜×*Ñ*Ñ+¨dÑ2Ó9Ø26€J��e×'Ñ'Ñ(¨4Ñ/Ó6Ø$(€Cˆ×	Ñ	˜TÑ	!Ó(Ø&*€Eˆ5×Ñ˜tÑ#Ö*r3   rf  z7
    Output type of [`PatchTSTForClassification`].
    c                   óÆ   • \ rS rSr% SrSr\R                  S-  \S'   Sr	\R                  S-  \S'   Sr
\\R                     S-  \S'   Sr\\R                     S-  \S'   Srg)	ÚPatchTSTForClassificationOutputiP  as  
loss (*optional*, returned when `labels` is provided, `torch.FloatTensor` of shape `(1,)`):
    Total loss as the sum of the masked language modeling loss and the next sequence prediction
    (classification) loss.
prediction_logits (`torch.FloatTensor` of shape `(batch_size, num_targets)`):
    Prediction scores of the PatchTST modeling head (scores before SoftMax).
Nr`  Úprediction_logitsrL   rQ  rž   )rb   rc   rd   re   rf   r`  r)   r]  r  rj  rL   rk   rQ  rl   rž   r3   r1   ri  ri  P  sh   ‡ ñð &*€Dˆ%×
Ñ
˜dÑ
"Ó)Ø26Ð�u×(Ñ(¨4Ñ/Ó6Ø59€M�5˜×*Ñ*Ñ+¨dÑ2Ó9Ø26€J��e×'Ñ'Ñ(¨4Ñ/Ö6r3   ri  zƒ
    Base class for time series model's predictions outputs that contains the sampled values from the chosen
    distribution.
    c                   óB   • \ rS rSr% SrSr\R                  S-  \S'   Sr	g)ÚSamplePatchTSTOutputie  z˜
sequences (`torch.FloatTensor` of shape `(batch_size, num_samples, prediction_length, num_targets)`):
    Sampled values from the chosen distribution.
NÚ	sequencesrž   )
rb   rc   rd   re   rf   rm  r)   r]  r  rl   rž   r3   r1   rl  rl  e  s   ‡ ñð
 +/€Iˆu× Ñ  4Ñ'Ö.r3   rl  ÚinputÚtargetrO   c                 ó&   • U R                  U5      * $ )z[
Computes the negative log likelihood loss from input distribution with respect to target.
)Úlog_prob)rn  ro  s     r1   Únllrr  v  s   € ð �N‰N˜6Ó"Ð"Ð"r3   Úinput_tensorÚweightsc                 óR  • Ub–  [         R                  " US:g  X-  [         R                  " U 5      5      n[         R                  " U(       a  UR	                  US9OUR	                  5       SS9nU(       a  UR	                  US9U-  $ UR	                  5       U-  $ U R                  US9$ )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   r$   ç      ð?©Úmin)r)   ÚwhereÚ
zeros_likeÚclampr¤   r<  )rs  rt  r%   Úweighted_tensorÚsum_weightss        r1   Úweighted_averager~  ~  s™   € ð  ÑÜŸ+š+ g°¡l°LÑ4JÌE×L\ÒL\Ð]iÓLjÓkˆÜ—k’k¾# '§+¡+°# +Ñ"6À7Ç;Á;Ã=ÐVYÑZˆÞ03�×#Ñ#¨Ð#Ð,ÐR]Ñ]Ð]¸×9LÑ9LÓ9NÐR]Ñ]Ð]à× Ñ  SÐ Ð)Ð)r3   c            	       óº   ^ • \ rS rSrSrS\4U 4S jjrS\R                  S\R                  S\	\R                  \R                  \R                  4   4S jr
S	rU =r$ )
ÚPatchTSTStdScaleri—  z±
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                 ó  >• [         TU ]  5         [        US5      (       a  UR                  OSU l        [        US5      (       a  UR
                  OSU l        [        US5      (       a  UR                  U l        g SU l        g )NÚscaling_dimr   ÚkeepdimTÚminimum_scalegñhãˆµøä>)r@   rA   Úhasattrr‚  r%   rƒ  r„  ry   s     €r1   rA   ÚPatchTSTStdScaler.__init__�  sd   ø€ Ü‰ÑÔÜ)0°¸×)GÑ)G�6×%Ò%ÈQˆŒÜ)0°¸×)CÑ)C�v—~’~ÈˆŒÜ5<¸VÀ_×5UÑ5U˜V×1Ñ1ˆÕÐ[_ˆÕr3   ÚdataÚobserved_indicatorrO   c                 ór  • UR                  U R                  U R                  S9nUR                  S5      nX-  R                  U R                  U R                  S9U-  nX-
  U-  S-  R                  U R                  U R                  S9U-  n[        R
                  " XPR                  -   5      nX-
  U-  XF4$ )áó  
Parameters:
    data (`torch.Tensor` of shape `(batch_size, sequence_length, num_input_channels)`):
        input for Batch norm calculation
    observed_indicator (`torch.BoolTensor` of shape `(batch_size, sequence_length, num_input_channels)`):
        Calculating the scale on the observed indicator.
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)`)
©rƒ  rv  r#   )r¤   r%   rƒ  Ú	clamp_minr)   Úsqrtr„  )rI   r‡  rˆ  Údenominatorr[  Úvariancer\  s          r1   r`   ÚPatchTSTStdScaler.forward£  s³   € ð )×,Ñ,¨T¯X©X¸t¿|¹|Ð,ÐLˆØ!×+Ñ+¨CÓ0ˆØÑ(×-Ñ-¨d¯h©hÀÇÁÐ-ÐMÐP[Ñ[ˆà‘jÐ$6Ñ6¸1Ñ<×AÑAÀ$Ç(Á(ÐTX×T`ÑT`ÐAÐaÐdoÑoˆÜ—
’
˜8×&8Ñ&8Ñ8Ó9ˆØ‘
˜eÑ# SÐ/Ð/r3   )r%   rƒ  r„  ©rb   rc   rd   re   rf   r   rA   r)   rj   rk   r`   rl   rm   rn   s   @r1   r€  r€  —  sX   ø† ñð
`˜~÷ `ð0Ø—L‘Lð0Ø6;·l±lð0à	ˆu�|‰|˜UŸ\™\¨5¯<©<Ð7Ñ	8÷0ò 0r3   r€  c            	       óº   ^ • \ rS rSrSrS\4U 4S jjrS\R                  S\R                  S\	\R                  \R                  \R                  4   4S jr
S	rU =r$ )
ÚPatchTSTMeanScaleri»  z~
Computes a scaling factor as the weighted average absolute value along the first dimension, and scales the data
accordingly.
r<   c                 óN  >• [         TU ]  5         [        US5      (       a  UR                  OSU l        [        US5      (       a  UR
                  OSU l        [        US5      (       a  UR                  OSU l        [        US5      (       a  UR                  U l        g S U l        g )Nr‚  r   rƒ  Tr„  ç»½×Ùß|Û=Údefault_scale)r@   rA   r…  r‚  r%   rƒ  r„  r–  ry   s     €r1   rA   ÚPatchTSTMeanScaler.__init__Á  s�   ø€ Ü‰ÑÔÜ)0°¸×)GÑ)G�6×%Ò%ÈQˆŒÜ)0°¸×)CÑ)C�v—~’~ÈˆŒÜ5<¸VÀ_×5UÑ5U˜V×1Ò1Ð[`ˆÔÜ5<¸VÀ_×5UÑ5U˜V×1Ñ1ˆÕÐ[_ˆÕr3   r‡  rˆ  rO   c                 ó°  • X-  R                  5       R                  U R                  SS9nUR                  U R                  SS9nU[        R                  " USS9-  nU R
                  cL  UR                  SS9n[        R                  " UR                  S5      SS9n[        R                  " Xg-  5      nO#U R
                  [        R                  " U5      -  n[        R                  " US:„  XX5      n[        R                  " XPR                  S9nX-  n	U R                  (       d  UR                  U R                  S9nU	[        R                  " U5      U4$ )rŠ  Tr‹  r   rw  r   r$   )Úabsr¤   r%   r)   r{  r–  ÚsqueezeÚ	ones_likery  r„  rƒ  rz  )
rI   r‡  rˆ  Úts_sumÚnum_observedr\  Ú	batch_sumÚbatch_observationsr–  Úscaled_datas
             r1   r`   ÚPatchTSTMeanScaler.forwardÈ  s"  € ð Ñ+×0Ñ0Ó2×6Ñ6°t·x±xÈÐ6ÐNˆØ)×-Ñ-¨d¯h©hÀÐ-ÐEˆàœŸš \°qÑ9Ñ9ˆð ×ÑÑ%ØŸ
™
 q˜
Ð)ˆIÜ!&§¢¨\×-=Ñ-=¸aÓ-@ÀaÑ!HÐÜ!ŸMšM¨)Ñ*HÓI‰Mà ×.Ñ.´·²ÀÓ1GÑGˆMô —’˜L¨1Ñ,¨eÓCˆô —’˜E×'9Ñ'9Ñ:ˆØ‘lˆà�|�|Ø—M‘M d§h¡h�MÐ/ˆEàœE×,Ò,¨UÓ3°UÐ:Ð:r3   )r–  r%   rƒ  r„  r‘  rn   s   @r1   r“  r“  »  sX   ø† ñð
`˜~÷ `ð&;Ø—L‘Lð&;Ø6;·l±lð&;à	ˆu�|‰|˜UŸ\™\¨5¯<©<Ð7Ñ	8÷&;ò &;r3   r“  c            
       óÆ   ^ • \ rS rSrSrS\4U 4S jjr SS\R                  S\R                  S-  S\	\R                  \R                  \R                  4   4S	 jjr
S
rU =r$ )ÚPatchTSTNOPScaleriò  zt
Assigns a scaling factor equal to 1 along the first dimension, and therefore applies no scaling to the input data.
r<   c                 ó¾   >• [         TU ]  5         [        US5      (       a  UR                  OSU l        [        US5      (       a  UR
                  U l        g SU l        g )Nr‚  r   rƒ  T)r@   rA   r…  r‚  r%   rƒ  ry   s     €r1   rA   ÚPatchTSTNOPScaler.__init__÷  sF   ø€ Ü‰ÑÔÜ)0°¸×)GÑ)G�6×%Ò%ÈQˆŒÜ)0°¸×)CÑ)C�v—~‘~ˆ�Èˆ�r3   Nr‡  rˆ  rO   c                 óæ   • [         R                  " USS9R                  U R                  U R                  S9n[         R
                  " USS9R                  U R                  U R                  S9nXU4$ )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)`)
Fr0  ©r%   rƒ  )r)   r›  r<  r%   rƒ  rz  )rI   r‡  rˆ  r\  r[  s        r1   r`   ÚPatchTSTNOPScaler.forwardü  sg   € ô —’ °EÑ:×?Ñ?ÀDÇHÁHÐVZ×VbÑVbÐ?ÐcˆÜ×Ò˜t°5Ñ9×>Ñ>À4Ç8Á8ÐUY×UaÑUaÐ>ÐbˆØ˜%ÐÐr3   r§  rÌ   r‘  rn   s   @r1   r£  r£  ò  sd   ø† ñðN˜~÷ Nð MQñ Ø—L‘Lð Ø6;·l±lÀTÑ6Ið à	ˆu�|‰|˜UŸ\™\¨5¯<©<Ð7Ñ	8÷ ó  r3   r£  c            	       ó¶   ^ • \ rS rSrS\4U 4S jjrS\R                  S\R                  S\\R                  \R                  \R                  4   4S jr	Sr
U =r$ )	ÚPatchTSTScaleri  r<   c                 óä   >• [         TU ]  5         UR                  S:X  d  UR                  SL a  [        U5      U l        g UR                  S:X  a  [        U5      U l        g [        U5      U l        g )Nr<  Trü   )r@   rA   r   r“  Úscalerr€  r£  ry   s     €r1   rA   ÚPatchTSTScaler.__init__  sU   ø€ Ü‰ÑÔØ�>‰>˜VÓ# v§~¡~¸Ò'=Ü,¨VÓ4ˆD�KØ�^‰^˜uÓ$Ü+¨FÓ3ˆD�Kä+¨FÓ3ˆD�Kr3   r‡  rˆ  rO   c                 ó2   • U R                  X5      u  pnXU4$ )aî  
Parameters:
    data (`torch.Tensor` of shape `(batch_size, sequence_length, num_input_channels)`):
        Input for scaler calculation
    observed_indicator (`torch.BoolTensor` of shape `(batch_size, sequence_length, num_input_channels)`):
        Calculating the scale on the observed indicator.
Returns:
    tuple of `torch.Tensor` of shapes
        (`(batch_size, sequence_length, num_input_channels)`,`(batch_size, 1, num_input_channels)`,
        `(batch_size, 1, um_input_channels)`)
©r¬  )rI   r‡  rˆ  r[  r\  s        r1   r`   ÚPatchTSTScaler.forward  s"   € ð  Ÿ;™; tÓ@Ñˆ�5Ø˜%ÐÐr3   r¯  )rb   rc   rd   re   r   rA   r)   rj   rk   r`   rl   rm   rn   s   @r1   rª  rª    sQ   ø† ð4˜~÷ 4ð Ø—L‘Lð Ø6;·l±lð à	ˆu�|‰|˜UŸ\™\¨5¯<©<Ð7Ñ	8÷ ò  r3   rª  c                   óÄ   ^ • \ rS rSrS\4U 4S jjr     SS\R                  S\R                  S-  S\R                  S-  S\S-  S	\S-  S
\S-  S\	\
-  4S jjrSrU =r$ )ÚPatchTSTModeli)  r<   c                 óf  >• [         TU ]  U5        [        U5      U l        [	        U5      U l        UR                  U l        U R
                  R                  nU R                  (       a  [        U5      U l	        O[        R                  " 5       U l	        [        XS9U l        U R                  5         g )N)r½   )r@   rA   rª  r¬  r·   Ú
patchifierÚdo_mask_inputr½   rÊ   Úmaskingr   rá   r  ÚencoderrL  r-  s      €r1   rA   ÚPatchTSTModel.__init__+  s   ø€ Ü‰Ñ˜Ô ä$ VÓ,ˆŒÜ*¨6Ó2ˆŒØ#×1Ñ1ˆÔà—o‘o×1Ñ1ˆà××Ü*¨6Ó2ˆD�LäŸ;š;›=ˆDŒLÜ& vÑGˆŒð 	�‰Õr3   NrÁ   Úpast_observed_maskÚfuture_valuesrN  rN   Úreturn_dictrO   c           
      óŽ  • Ub  UOU R                   R                  nUb  UOU R                   R                  nUb  UOU R                   R                  nUc  [        R
                  " U5      nU R                  X5      u  p‰n
U R                  U5      nU R                  (       a  U R                  U5      u  pÍOU R                  U5      SpÜU R                  XÄUS9nU(       d<  UR                  UR                  UR                  4nXýXšU4-   n[        S U 5       5      $ [        UR                  UR                  UR                  UU	U
US9$ )aï  
Parameters:
    past_values (`torch.Tensor` of shape `(bs, sequence_length, num_input_channels)`, *required*):
        Input sequence to the model
    past_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).
    future_values (`torch.BoolTensor` of shape `(batch_size, prediction_length, num_input_channels)`, *optional*):
        Future target values associated with the `past_values`
    output_hidden_states (`bool`, *optional*):
        Whether or not to return the hidden states of all layers
    output_attentions (`bool`, *optional*):
        Whether or not to return the output attention of all layers
    return_dict (`bool`, *optional*):
        Whether or not to return a `ModelOutput` instead of a plain tuple.

Returns:
    `PatchTSTModelOutput` or tuple of `torch.Tensor` (if `return_dict`=False or `config.return_dict`=False)

Examples:

```python
>>> from huggingface_hub import hf_hub_download
>>> import torch
>>> from transformers import PatchTSTModel

>>> file = hf_hub_download(
...     repo_id="hf-internal-testing/etth1-hourly-batch", filename="train-batch.pt", repo_type="dataset"
... )
>>> batch = torch.load(file)

>>> model = PatchTSTModel.from_pretrained("namctin/patchtst_etth1_pretrain")

>>> # during training, one provides both past and future values
>>> outputs = model(
...     past_values=batch["past_values"],
...     future_values=batch["future_values"],
... )

>>> last_hidden_state = outputs.last_hidden_state
```N)rÐ   rN  rN   c              3   ó.   #   • U  H  oc  M  Uv •  M     g 7frÌ   rž   )Ú.0Úvs     r1   Ú	<genexpr>Ú(PatchTSTModel.forward.<locals>.<genexpr>Ž  s   é € Ð=¢G˜qŸ™¢Gùs   ‚Œ	)rP  rL   rQ  r–   r[  r\  rÐ   )r<   r»  rN   rN  r)   r›  r¬  r´  rµ  r¶  r·  rP  rL   rQ  rk   rZ  )rI   rÁ   r¹  rº  rN  rN   r»  r   Úscaled_past_valuesr[  r\  Úpatched_valuesÚmasked_valuesr–   Úencoder_outputrõ   s                   r1   r`   ÚPatchTSTModel.forward=  sK  € ðn &1Ñ%<‘kÀ$Ç+Á+×BYÑBYˆØ1BÑ1NÑ-ÐTX×T_ÑT_×TqÑTqÐà$8Ñ$DÑ È$Ï+É+×JjÑJjð 	ð Ñ%Ü!&§¢°Ó!=Ðð *.¯©°[Ó)UÑ&Ð ð Ÿ™Ð);Ó<ˆØ××Ø"&§,¡,¨~Ó">ÑˆM˜4à"&§,¡,¨~Ó">À˜4àŸ™Ø%Ðduð &ð 
ˆö Ø%×7Ñ7¸×9UÑ9UÐWe×WpÑWpÐqˆGØ s°>Ð BÑBˆGÜÑ=¡GÓ=Ó=Ð=ä"Ø,×>Ñ>Ø(×6Ñ6Ø%×0Ñ0ØØØØ&ñ
ð 	
r3   )rµ  r·  r¶  r´  r¬  ©NNNNN)rb   rc   rd   re   r   rA   r)   rj   ri   rk   rZ  r`   rl   rm   rn   s   @r1   r²  r²  )  sŸ   ø† ð˜~÷ ð* 37Ø-1Ø,0Ø)-Ø#'ñ[
à—\‘\ð[
ð "ŸL™L¨4Ñ/ð[
ð —|‘| dÑ*ð	[
ð
 # T™kð[
ð   $™;ð[
ð ˜D‘[ð[
ð 
Ð$Ñ	$÷[
ó [
r3   r²  c                   ón   ^ • \ rS rSrSrS\4U 4S jjrS\R                  S\R                  4S jr	Sr
U =r$ )	ÚPatchTSTMaskPretrainHeadi›  z%
Pretraining head for mask modelling
r<   c                 ó8  >• [         TU ]  5         UR                  S:”  a   [        R                  " UR                  5      O[        R
                  " 5       U l        [        R                  " UR                  UR                  5      U l
        UR                  U l        g ©Nr   )r@   rA   Úhead_dropoutr   rà   rá   r   rD   rv   r®   Úlinearr   ry   s     €r1   rA   Ú!PatchTSTMaskPretrainHead.__init__   sh   ø€ Ü‰ÑÔØ:@×:MÑ:MÐPQÓ:Q”r—z’z &×"5Ñ"5Ô6ÔWY×WbÒWbÓWdˆŒÜ—i’i §¡°×0CÑ0CÓDˆŒØ#×1Ñ1ˆÕr3   Ú	embeddingrO   c                 óŠ   • U R                  U R                  U5      5      nU R                  (       a  USS2SS2SS2SS24   nU$ )a›  
Parameters:
    embedding (`torch.Tensor` of shape `(bs, num_channels, num_patches, d_model)` or
            `(bs, num_channels, num_patches+1, d_model)` if `cls_token` is set to True, *required*):
        Embedding from the model
Returns:
    `torch.Tensor` of shape `(bs, num_channels, num_patches, d_model)` or
                    `(bs, num_channels, num_patches+1, d_model)` if `cls_token` is set to True

Nr   )rÍ  r   r   )rI   rÏ  s     r1   r`   Ú PatchTSTMaskPretrainHead.forward¦  s>   € ð —K‘K §¡¨YÓ 7Ó8ˆ	Ø××Ø!¢!¢Q¨©ªA +Ñ.ˆIØÐr3   )r   rÍ  r   r   rn   s   @r1   rÉ  rÉ  ›  s4   ø† ñð2˜~÷ 2ð §¡ð °%·,±,÷ ò r3   rÉ  z*
    The PatchTST for pretrain model.
    c                   ó¤   ^ • \ rS rSrS\4U 4S jjr    SS\R                  S\R                  S-  S\S-  S\S-  S	\S-  S
\	\
-  4S jjrSrU =r$ )ÚPatchTSTForPretrainingi·  r<   c                 óŽ   >• [         TU ]  U5        SUl        [        US9U l        [        U5      U l        U R                  5         g )NT)r<   )r@   rA   rµ  r²  rù   rÉ  ÚheadrL  ry   s     €r1   rA   ÚPatchTSTForPretraining.__init__½  s<   ø€ Ü‰Ñ˜Ô à#ˆÔÜ"¨&Ñ1ˆŒ
Ü,¨VÓ4ˆŒ	ð 	�‰Õr3   NrÁ   r¹  rN  rN   r»  rO   c                 óî  • Ub  UOU R                   R                  nU R                  UUUUSS9nU R                  UR                  5      n[
        R                  " SS9n	U	" X‡R                  5      n
U
R                  SS9UR                  -  R                  5       UR                  R                  5       S-   -  nUR                  nU(       d  U4USS	 -   nUb  U4U-   nU$ UnU$ [        X¸XÇR                  S
9$ )a  
Parameters:
    past_values (`torch.Tensor` of shape `(bs, sequence_length, num_input_channels)`, *required*):
        Input sequence to the model
    past_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).
    output_hidden_states (`bool`, *optional*):
        Whether or not to return the hidden states of all layers
    output_attentions (`bool`, *optional*):
        Whether or not to return the output attention of all layers
    return_dict (`bool`, *optional*): Whether or not to return a `ModelOutput` instead of a plain tuple.

Returns:
    `PatchTSTForPretrainingOutput` or tuple of `torch.Tensor` (if `return_dict`=False or
    `config.return_dict`=False)

Examples:

```python
>>> from huggingface_hub import hf_hub_download
>>> import torch
>>> from transformers import PatchTSTConfig, PatchTSTForPretraining

>>> file = hf_hub_download(
...     repo_id="hf-internal-testing/etth1-hourly-batch", filename="train-batch.pt", repo_type="dataset"
... )
>>> batch = torch.load(file)

>>> # Config for random mask pretraining
>>> config = PatchTSTConfig(
...     num_input_channels=7,
...     context_length=512,
...     patch_length=12,
...     stride=12,
...     mask_type='random',
...     random_mask_ratio=0.4,
...     use_cls_token=True,
... )
>>> # Config for forecast mask pretraining
>>> config = PatchTSTConfig(
...     num_input_channels=7,
...     context_length=512,
...     patch_length=12,
...     stride=12,
...     mask_type='forecast',
...     num_forecast_mask_patches=5,
...     use_cls_token=True,
... )
>>> model = PatchTSTForPretraining(config)

>>> # during training, one provides both past and future values
>>> outputs = model(past_values=batch["past_values"])

>>> loss = outputs.loss
>>> loss.backward()
```T©rÁ   r¹  rN  rN   r»  Únone©Ú	reductionr!   r$   r•  r   éüÿÿÿ)r`  ra  rL   rQ  )r<   r»  rù   rÕ  rP  r   ÚMSELossrÐ   r<  r–   r¤   rL   r_  rQ  )rI   rÁ   r¹  rN  rN   r»  r   Úmodel_outputÚx_hatr`  Úloss_valÚmasked_lossrR  rõ   s                 r1   r`   ÚPatchTSTForPretraining.forwardÇ  s  € ðL &1Ñ%<‘kÀ$Ç+Á+×BYÑBYˆð —z‘zØ#Ø1Ø!5Ø/Øð "ð 
ˆð —	‘	˜,×8Ñ8Ó9ˆô �zŠz FÑ+ˆÙ˜×7Ñ7Ó8ˆØ—}‘}¨�}Ð,¨|×/@Ñ/@Ñ@×EÑEÓGÈ<×K\ÑK\×K`ÑK`ÓKbÐejÑKjÑkˆà%×3Ñ3ˆÞØ�h ¨a°Ð!3Ñ3ˆGØ2=Ñ2I�{�n wÑ.ˆGØˆNð PWˆGØˆNÜ+ØÀ^×`wÑ`wñ
ð 	
r3   ©rÕ  rù   )NNNN)rb   rc   rd   re   r   rA   r)   rj   ri   rk   r_  r`   rl   rm   rn   s   @r1   rÓ  rÓ  ·  sˆ   ø† ð˜~÷ ð 37Ø,0Ø)-Ø#'ñb
à—\‘\ðb
ð "ŸL™L¨4Ñ/ðb
ð # T™kð	b
ð
   $™;ðb
ð ˜D‘[ðb
ð 
Ð-Ñ	-÷b
ó b
r3   rÓ  c                   óR   ^ • \ rS rSrS\4U 4S jjrS\R                  4S jrSr	U =r
$ )ÚPatchTSTClassificationHeadi,  r<   c                 ó¦  >• [         TU ]  5         UR                  U l        UR                  U l        [        R
                  " SS9U l        UR                  S:”  a   [        R                  " UR                  5      O[        R                  " 5       U l
        [        R                  " UR                  UR                  -  UR                  5      U l        g ©Nr   ©Ú	start_dimr   )r@   rA   r   Úpooling_typer   ÚFlattenÚflattenrÌ  rà   rá   r   rD   ró   rv   Únum_targetsrÍ  ry   s     €r1   rA   Ú#PatchTSTClassificationHead.__init__-  s‘   ø€ Ü‰ÑÔØ#×1Ñ1ˆÔØ"×/Ñ/ˆÔÜ—z’z¨AÑ.ˆŒØ:@×:MÑ:MÐPQÓ:Q”r—z’z &×"5Ñ"5Ô6ÔWY×WbÒWbÓWdˆŒÜ—i’i × 9Ñ 9¸F¿N¹NÑ JÈF×L^ÑL^Ó_ˆ�r3   rÏ  c                 óp  • U R                   (       a  USS2SS2SSS24   nOcU R                  S:X  a  UR                  SS9nOCU R                  S:X  a  UR                  SS9R                  nO[        SU R                   S35      eU R                  U5      nU R                  U R                  U5      5      nU$ )	a#  
Parameters:
    embedding (`torch.Tensor` of shape `(bs, num_channels, num_patches, d_model)` or
             `(bs, num_channels, num_patches+1, d_model)` if `cls_token` is set to True, *required*):
        Embedding from the model
Returns:
    `torch.Tensor` of shape `(bs, num_targets)`

Nr   r<  r#   r$   r¼   úpooling operator ú is not implemented yet)	r   rê  r<  r¼   ÚvaluesrC   rì  rÍ  r   ©rI   rÏ  Úpooled_embeddingr}   s       r1   r`   Ú"PatchTSTClassificationHead.forward5  s®   € ð ××à(ªªA¨q²!¨Ñ4ÑØ×Ñ &Ó(à(Ÿ~™~°!˜~Ð4ÑØ×Ñ %Ó'à(Ÿ}™}°˜}Ð3×:Ñ:ÑäÐ0°×1BÑ1BÐ0CÐCZÐ[Ó\Ð\àŸ<™<Ð(8Ó9Ðà—‘˜TŸ\™\Ð*:Ó;Ó<ˆØˆr3   )r   rì  rÍ  rê  r   r(  rn   s   @r1   rå  rå  ,  s&   ø† ð`˜~÷ `ð §¡÷ ò r3   rå  z0
    The PatchTST for classification model.
    c                   óº   ^ • \ rS rSrS\4U 4S jjr\     SS\R                  S\R                  S-  S\	S-  S\	S-  S	\	S-  S
\	S-  S\
\-  4S jj5       rSrU =r$ )ÚPatchTSTForClassificationiQ  r<   c                 óÞ   >• [         TU ]  U5        UR                  (       a  [        R	                  S5        SUl        [        U5      U l        [        U5      U l        U R                  5         g )Nú+Setting `do_mask_input` parameter to False.F)
r@   rA   rµ  ÚloggerÚwarningr²  rù   rå  rÕ  rL  ry   s     €r1   rA   Ú"PatchTSTForClassification.__init__W  sT   ø€ Ü‰Ñ˜Ô ð ××Ü�N‰NÐHÔIØ#(ˆFÔ ä" 6Ó*ˆŒ
Ü.¨vÓ6ˆŒ	ð 	�‰Õr3   NrÁ   Útarget_valuesr¹  rN  rN   r»  rO   c                 óV  • Ub  UOU R                   R                  nU R                  UUUUSS9nU R                  UR                  5      n	Sn
Ub  [
        R                  " 5       nU" X’5      n
U(       d  U	4USS -   nU
b  U
4U-   nU$ UnU$ [        U
U	UR                  UR                  S9$ )a‹  
past_values (`torch.Tensor` of shape `(bs, sequence_length, num_input_channels)`, *required*):
    Input sequence to the model
target_values (`torch.Tensor`, *optional*):
    Labels associates with the `past_values`
past_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).

Examples:

```python
>>> from transformers import PatchTSTConfig, PatchTSTForClassification

>>> # classification task with two input channel2 and 3 classes
>>> config = PatchTSTConfig(
...     num_input_channels=2,
...     num_targets=3,
...     context_length=512,
...     patch_length=12,
...     stride=12,
...     use_cls_token=True,
... )
>>> model = PatchTSTForClassification(config=config)

>>> # during inference, one only provides past values
>>> past_values = torch.randn(20, 512, 2)
>>> outputs = model(past_values=past_values)
>>> labels = outputs.prediction_logits
```NTrØ  r   rÆ   )r`  rj  rL   rQ  )
r<   r»  rù   rÕ  rP  r   ÚCrossEntropyLossri  rL   rQ  )rI   rÁ   rý  r¹  rN  rN   r»  r   rÞ  Úy_hatrà  r`  rõ   s                r1   r`   Ú!PatchTSTForClassification.forwarde  sÕ   € ðZ &1Ñ%<‘kÀ$Ç+Á+×BYÑBYˆà—z‘zØ#Ø1Ø!5Ø/Øð "ð 
ˆð —	‘	˜,×8Ñ8Ó9ˆàˆØÑ$Ü×&Ò&Ó(ˆDÙ˜EÓ1ˆHæØ�h ¨a°Ð!3Ñ3ˆGØ/7Ñ/C�x�k GÑ+ˆGØˆNð JQˆGØˆNÜ.ØØ#Ø&×4Ñ4Ø#×.Ñ.ñ	
ð 	
r3   rã  rÇ  )rb   rc   rd   re   r   rA   r   r)   rj   ri   rk   ri  r`   rl   rm   rn   s   @r1   r÷  r÷  Q  s¤   ø† ð˜~÷ ð ð .2Ø*.Ø,0Ø)-Ø#'ñE
à—\‘\ðE
ð —|‘| dÑ*ðE
ð ! 4™Kð	E
ð
 # T™kðE
ð   $™;ðE
ð ˜D‘[ðE
ð 
Ð0Ñ	0ôE
ó öE
r3   r÷  z,
    The PatchTST for regression Model.
    c                   óZ   ^ • \ rS rSrSS\S\4U 4S jjjrS\R                  4S jr	Sr
U =r$ )	ÚPatchTSTPredictionHeadi®  r<   r½   c                 óH  >• [         TU ]  5         UR                  U l        UR                  U l        UR                  U l        UR
                  U l        U R
                  (       d  U R                  (       a  UR                  nOUR                  U-  nU R                  (       Gd]  [        R                  " 5       U l	        [        R                  " 5       U l
        [        R                  " 5       U l        [        U R                  5       Hõ  nU R                  R                  [        R                  " SS95        Uc:  U R                  R                  [        R                  " XAR                   5      5        O*U R                  R                  UR#                  U5      5        U R                  R                  UR$                  S:”  a   [        R&                  " UR$                  5      O[        R(                  " 5       5        M÷     g[        R                  " SS9U l        Uc&  [        R                  " XAR                   5      U l        OUR#                  U5      U l        UR$                  S:”  a   [        R&                  " UR$                  5      O[        R(                  " 5       U l        g)zè
num_patches (`int`):
    The number of patches in the input sequence.
distribution_output (`DistributionOutput`, *optional*):
    The distribution output layer for probabilistic forecasting. If None, a linear output layer is used.
r#   rè  Nr   )r@   rA   Úshare_projectionró   r   rê  rv   r   r   ÚprojectionsÚdropoutsÚflattensr!  r¦   rë  rD   Úprediction_lengthÚget_parameter_projectionrÌ  rà   rá   rì  Ú
projectionr   )rI   r<   r½   Údistribution_outputrB   r&  rJ   s         €r1   rA   ÚPatchTSTPredictionHead.__init__´  sÍ  ø€ ô 	‰ÑÔà &× 7Ñ 7ˆÔØ"(×";Ñ";ˆÔØ#×1Ñ1ˆÔØ"×/Ñ/ˆÔØ×× × 2× 2Ø—~‘~‰Hà—~‘~¨Ñ3ˆHà×$×$Ð$ä!Ÿ}š}›ˆDÔÜŸMšM›OˆDŒMÜŸMšM›OˆDŒMÜ˜4×2Ñ2Ö3�Ø—‘×$Ñ$¤R§Z¢Z¸!Ñ%<Ô=Ø&Ñ.à×$Ñ$×+Ñ+¬B¯IªI°h×@XÑ@XÓ,YÕZð ×$Ñ$×+Ñ+Ð,?×,XÑ,XÐYaÓ,bÔcØ—‘×$Ñ$È×H[ÑH[Ð^_ÓH_¤R§Z¢Z°×0CÑ0CÔ%DÔeg×epÒepÓerÖsò 4ô Ÿ:š:°Ñ2ˆDŒLØ"Ñ*ä"$§)¢)¨H×6NÑ6NÓ"O�•ð #6×"NÑ"NÈxÓ"X�”Ø>D×>QÑ>QÐTUÓ>Uœ2Ÿ:š: f×&9Ñ&9Ô:Ô[]×[fÒ[fÓ[hˆD�Lr3   rÏ  c                 óú  • U R                   (       a  USS2SS2SSS24   nOLU R                  S:X  a  UR                  SS9nO,U R                  S:X  a  UR                  SS9R                  nOUnU R
                  (       dŽ  / n[        U R                  5       H]  nU R                  U   " USS2USS24   5      nU R                  U   " U5      nU R                  U   " U5      nUR                  U5        M_     [        R                  " USS9nO3U R                  U5      nU R                  U5      nU R!                  U5      n[#        U[$        5      (       a  [%        S U 5       5      nU$ UR'                  SS5      nU$ )	a2  
Parameters:
    embedding (`torch.Tensor` of shape `(bs, num_channels, num_patches, d_model)` or
             `(bs, num_channels, num_patches+1, d_model)` if `cls_token` is set to True, *required*):
        Embedding from the model
Returns:
    `torch.Tensor` of shape `(bs, forecast_len, num_channels)`

Nr   r<  r#   r$   r¼   r   c              3   óD   #   • U  H  oR                  S S5      v •  M     g7f)r#   r   N)r+   )r¾  Úzs     r1   rÀ  Ú1PatchTSTPredictionHead.forward.<locals>.<genexpr>  s   é € Ð=²f°Ÿ;™; q¨!×,Ð,²fùs   ‚ )r   rê  r<  r¼   rò  r  r!  ró   r  r  r  r¦   r)   r$  rì  r   r  r¢   rk   r+   )rI   rÏ  rô  r}   r&  s        r1   r`   ÚPatchTSTPredictionHead.forwardß  sl  € ð ××à(ªªA¨q²!¨Ñ4Ñà× Ñ  FÓ*à#,§>¡>°a >Ð#8Ñ Ø×"Ñ" eÓ+à#,§=¡=°Q =Ð#7×#>Ñ#>Ñ ð $-Ð à×$×$ØˆFÜ˜4×2Ñ2Ö3�à#'§=¡=°Ò#3Ð4DÂQÈÊ1ÀWÑ4MÓ#NÐ Ø#'§=¡=°Ò#3Ð4DÓ#EÐ ð $(×#3Ñ#3°AÒ#6Ð7GÓ#HÐ Ø—‘Ð.Ö/ñ 4ô —[’[ ¨QÑ/‰Fð  $Ÿ|™|Ð,<Ó=ÐØ#Ÿ|™|Ð,<Ó=Ðð —_‘_Ð%5Ó6ˆFä�fœe×$Ñ$äÑ=±fÓ=Ó=ˆFð ˆð ×%Ñ% a¨Ó+ˆFØˆr3   )
r   r  rì  r  ró   rê  r  r  r  r   rÌ   )rb   rc   rd   re   r   rg   rA   r)   rj   r`   rl   rm   rn   s   @r1   r  r  ®  s5   ø† ñ)i˜~ð )i¸C÷ )ið )iðV1 §¡÷ 1ò 1r3   r  z,
    The PatchTST for prediction model.
    c                   ó6  ^ • \ rS rSrS\4U 4S jjr     SS\R                  S\R                  S-  S\R                  S-  S\S-  S	\S-  S
\S-  S\	\
-  4S jjr\R                  " 5        SS\R                  S\R                  S-  S\4S jj5       rSrU =r$ )ÚPatchTSTForPredictioni  r<   c                 ó‚  >• [         TU ]  U5        UR                  (       a  [        R	                  S5        SUl        [        U5      U l        UR                  S:X  a  S U l        O“UR                  S:X  a  [        UR                  S9U l        OjUR                  S:X  a  [        UR                  S9U l        OAUR                  S:X  a  [        UR                  S9U l        O[        SUR                   35      e[        XR                  R                  R                   U R                  S	9U l        U R%                  5         g )
Nrù  FÚmseÚ	student_tr$   ÚnormalÚnegative_binomialúUnknown distribution output )r  )r@   rA   rµ  rú  rû  r²  rù   r`  r  r   r	  r   r   rC   r  r´  r½   rÕ  rL  ry   s     €r1   rA   ÚPatchTSTForPrediction.__init__  s  ø€ Ü‰Ñ˜Ô ð ××Ü�N‰NÐHÔIØ#(ˆFÔ ä" 6Ó*ˆŒ
à�;‰;˜%ÓØ'+ˆDÕ$à×)Ñ)¨[Ó8Ü+9¸f×>VÑ>VÑ+W�Õ(Ø×+Ñ+¨xÓ7Ü+7¸F×<TÑ<TÑ+U�Õ(Ø×+Ñ+Ð/BÓBÜ+AÀf×F^ÑF^Ñ+_�Õ(ä Ð#?À×@ZÑ@ZÐ?[Ð!\Ó]Ð]ä*Ø—J‘J×)Ñ)×5Ñ5È4×KcÑKcñ
ˆŒ	ð
 	�‰Õr3   NrÁ   r¹  rº  rN  rN   r»  rO   c           	      ó’  • Ub  UOU R                   R                  nU R                  UUUUSS9nU R                  UR                  5      n	Sn
U R
                  (       a  U	nOX˜R                  -  UR                  -   nUbr  U R
                  (       aE  U R
                  R                  X˜R                  UR                  S9n[        XÃ5      n
[        U
5      n
O[        R                  " SS9nU" X³5      n
UR                  nUR                  nU(       d  U4USS -   nU
b  U
4U-   nU$ UnU$ [        U
UUR                  UR                  UUS	9$ )
a  
Parameters:
    past_values (`torch.Tensor` of shape `(bs, sequence_length, num_input_channels)`, *required*):
        Input sequence to the model
    past_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).
    future_values (`torch.Tensor` of shape `(bs, forecast_len, num_input_channels)`, *optional*):
        Future target values associated with the `past_values`
    output_hidden_states (`bool`, *optional*):
        Whether or not to return the hidden states of all layers
    output_attentions (`bool`, *optional*):
        Whether or not to return the output attention of all layers
    return_dict (`bool`, *optional*):
        Whether or not to return a `ModelOutput` instead of a plain tuple.

Returns:
    `PatchTSTForPredictionOutput` or tuple of `torch.Tensor` (if `return_dict`=False or
    `config.return_dict`=False)

Examples:

```python
>>> from huggingface_hub import hf_hub_download
>>> import torch
>>> from transformers import PatchTSTConfig, PatchTSTForPrediction

>>> file = hf_hub_download(
...     repo_id="hf-internal-testing/etth1-hourly-batch", filename="train-batch.pt", repo_type="dataset"
... )
>>> batch = torch.load(file)

>>> # Prediction task with 7 input channels and prediction length is 96
>>> model = PatchTSTForPrediction.from_pretrained("namctin/patchtst_etth1_forecast")

>>> # during training, one provides both past and future values
>>> outputs = model(
...     past_values=batch["past_values"],
...     future_values=batch["future_values"],
... )

>>> loss = outputs.loss
>>> loss.backward()

>>> # during inference, one only provides past values, the model outputs future values
>>> outputs = model(past_values=batch["past_values"])
>>> prediction_outputs = outputs.prediction_outputs
```NTrØ  ©r[  r\  r<  rÚ  r   r!   )r`  rg  rL   rQ  r[  r\  )r<   r»  rù   rÕ  rP  r  r\  r[  Údistributionrr  r~  r   rÝ  rf  rL   rQ  )rI   rÁ   r¹  rº  rN  rN   r»  r   rÞ  r   rà  Ú	y_hat_outr  r`  r[  r\  rõ   s                    r1   r`   ÚPatchTSTForPrediction.forward6  sf  € ð| &1Ñ%<‘kÀ$Ç+Á+×BYÑBYˆð —z‘zØ#Ø1Ø!5Ø/Øð "ð 
ˆð —	‘	˜,×8Ñ8Ó9ˆàˆà×#×#Ø‰Ià× 2Ñ 2Ñ2°\×5EÑ5EÑEˆIàÑ$Ø×'×'Ø#×7Ñ7×DÑDØ×/Ñ/°|×7IÑ7Ið  Eð  �ô ˜|Ó;�ä+¨HÓ5‘ä—z’z¨FÑ3�Ù 	Ó9�à×ÑˆØ×"Ñ"ˆæØ �l \°!°BÐ%7Ñ7ˆGØ/7Ñ/C�x�k GÑ+ˆGØˆNð JQˆGØˆNÜ*ØØ(Ø&×4Ñ4Ø#×.Ñ.ØØñ
ð 	
r3   c                 ó¢  • U R                   R                  nU " USUSS9nU R                  (       aw  U R                  R                  UR                  UR
                  UR                  S9n[        U5       Vs/ s H  oeR                  5       PM     nn[        R                  " USS9nOUR                  R                  S5      n[        US9$ s  snf )a°  
Generate sequences of sample predictions from a model with a probability distribution head.

Parameters:
    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.
    past_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:
    [`SamplePatchTSTOutput`] where the outputs `sequences` tensor will have shape `(batch_size, number of
    samples, prediction_length, 1)` or `(batch_size, number of samples, prediction_length, num_input_channels)`
    for multivariate predictions.
NF)rÁ   rº  r¹  rN  r  r   r$   ©rm  )r<   Únum_parallel_samplesr  r  rg  r[  r\  r!  Úsampler)   r$  rŽ   rl  ©rI   rÁ   r¹  r#  rõ   r  r©   Úsampless           r1   ÚgenerateÚPatchTSTForPrediction.generate¤  sÄ   € ð2  $Ÿ{™{×?Ñ?Ðñ Ø#ØØ1Ø!&ñ	
ˆð ×#×#à×3Ñ3×@Ñ@Ø×*Ñ*°·±À7Ç=Á=ð Að ˆLô 7<Ð<PÔ6QÓRÒ6Q°×*Ñ*Ö,Ñ6QˆGÐRä—k’k '¨qÑ1‰Gà×0Ñ0×:Ñ:¸1Ó=ˆGä#¨gÑ6Ð6ùò Ss   Á7C©r  rÕ  rù   rÇ  rÌ   )rb   rc   rd   re   r   rA   r)   rj   ri   rk   rf  r`   r  rl  r'  rl   rm   rn   s   @r1   r  r    sã   ø† ð˜~÷ ð@ 37Ø-1Ø,0Ø)-Ø#'ñl
à—\‘\ðl
ð "ŸL™L¨4Ñ/ðl
ð —|‘| dÑ*ð	l
ð
 # T™kðl
ð   $™;ðl
ð ˜D‘[ðl
ð 
Ð,Ñ	,õl
ð\ ‡]‚]ƒ_ð 37ñ-7à—\‘\ð-7ð "ŸL™L¨4Ñ/ð-7ð 
ô	-7ó ö-7r3   r  c                   óZ   ^ • \ rS rSrSrSS\4U 4S jjjrS\R                  4S jr	Sr
U =r$ )	ÚPatchTSTRegressionHeadiÕ  z
Regression head
r<   c                 ó
  >• [         TU ]  5         UR                  U l        UR                  U l        UR
                  U l        X l        UR                  UR                  -  n[        R                  " SS9U l        UR                  S:”  a   [        R                  " UR                  5      O[        R                  " 5       U l        Uc&  [        R                   " X1R"                  5      U l        g UR'                  U5      U l        g rç  )r@   rA   Úoutput_rangeÚy_ranger   rê  r  ró   rv   r   rë  rì  rÌ  rà   rá   r   rD   rí  r  r
  )rI   r<   r  rB   rJ   s       €r1   rA   ÚPatchTSTRegressionHead.__init__Ú  s¿   ø€ Ü‰ÑÔØ×*Ñ*ˆŒØ#×1Ñ1ˆÔØ"×/Ñ/ˆÔØ#6Ô à×,Ñ,¨v¯~©~Ñ=ˆä—z’z¨AÑ.ˆŒØ:@×:MÑ:MÐPQÓ:Q”r—z’z &×"5Ñ"5Ô6ÔWY×WbÒWbÓWdˆŒàÑ&Ü Ÿiši¨×2DÑ2DÓEˆD�Oà1×JÑJÈ8ÓTˆD�Or3   rÏ  c                 ó@  • U R                   (       a  USS2SS2SSS24   nOcU R                  S:X  a  UR                  SS9nOCU R                  S:X  a  UR                  SS9R                  nO[        SU R                   S35      eU R                  U R                  U5      5      nU R                  U5      nU R                  SL U R                  SL-  (       aF  [        R                  " U5      U R                  S	   U R                  S   -
  -  U R                  S   -   nU$ )
a!  
Parameters:
    embedding (`torch.Tensor` of shape `(bs, num_channels, num_patches, d_model)` or
            `(bs, num_channels, num_patches+1, d_model)` if `cls_token` is set to True, *required*):
        Embedding from the model
Returns:
    `torch.Tensor` of shape `(bs, output_dim)`

Nr   r<  r#   r$   r¼   rð  rñ  r   )r   rê  r<  r¼   rò  rC   r   rì  r  r  r.  r)   Úsigmoidró  s       r1   r`   ÚPatchTSTRegressionHead.forwardë  s  € ð ××à(ªªA¨q²!¨Ñ4ÑØ×Ñ &Ó(à(Ÿ~™~°!˜~Ð4ÑØ×Ñ %Ó'à(Ÿ}™}°˜}Ð3×:Ñ:ÑäÐ0°×1BÑ1BÐ0CÐCZÐ[Ó\Ð\ð  Ÿ<™<¨¯©Ð5EÓ(FÓGÐð —‘Ð!1Ó2ˆà×$Ñ$¨Ð,°·±ÀTÐ1I×JÜ—]’] 6Ó*¨d¯l©l¸1©oÀÇÁÈQÁÑ.OÑPÐSW×S_ÑS_Ð`aÑSbÑbˆFØˆr3   )r  r   rì  rê  r  r   r.  rÌ   r   rn   s   @r1   r+  r+  Õ  s1   ø† ññU˜~÷ Uð Uð" §¡÷ ò r3   r+  z,
    The PatchTST for regression model.
    c                   ó@  ^ • \ rS rSrS\4U 4S jjr\     SS\R                  S\R                  S-  S\R                  S-  S\	S-  S	\	S-  S
\	S-  S\
\-  4S jj5       r\R                  " 5        SS\R                  S\R                  S-  S\4S jj5       rSrU =r$ )ÚPatchTSTForRegressioni  r<   c                 óH  >• [         TU ]  U5        UR                  (       a  [        R	                  S5        SUl        [        U5      U l        UR                  S:X  a  S U l        O“UR                  S:X  a  [        UR                  S9U l        OjUR                  S:X  a  [        UR                  S9U l        OAUR                  S:X  a  [        UR                  S9U l        O[        SUR                   35      e[        XR                  5      U l        U R!                  5         g )	Nrù  Fr  r  r$   r  r  r  )r@   rA   rµ  rú  rû  r²  rù   r`  r  r   rí  r   r   rC   r+  rÕ  rL  ry   s     €r1   rA   ÚPatchTSTForRegression.__init__  sì   ø€ Ü‰Ñ˜Ô ð ××Ü�N‰NÐHÔIØ#(ˆFÔ ä" 6Ó*ˆŒ
Ø�;‰;˜%ÓØ'+ˆDÕ$à×)Ñ)¨[Ó8Ü+9¸f×>PÑ>PÑ+Q�Õ(Ø×+Ñ+¨xÓ7Ü+7¸F×<NÑ<NÑ+O�Õ(Ø×+Ñ+Ð/BÓBÜ+AÀf×FXÑFXÑ+Y�Õ(ä Ð#?À×@ZÑ@ZÐ?[Ð!\Ó]Ð]ä*¨6×3KÑ3KÓLˆŒ	ð 	�‰Õr3   NrÁ   rý  r¹  rN  rN   r»  rO   c                 ó  ^ • Ub  UOT R                   R                  nT R                  UUUUSS9nT R                  UR                  5      n	Sn
Ubt  T R
                  (       aG  T R
                  R                  U	5      n[        U 4S jU	 5       5      n	[        X²5      n
[        U
5      n
O[        R                  " SS9n
U
" X’5      n
U(       d  U	4USS -   nU
b  U
4U-   nU$ UnU$ [        U
U	UR                  UR                  S	9$ )
aƒ  
past_values (`torch.Tensor` of shape `(bs, sequence_length, num_input_channels)`, *required*):
    Input sequence to the model
target_values (`torch.Tensor` of shape `(bs, num_input_channels)`):
    Target values associates with the `past_values`
past_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).
    Whether or not to return a `ModelOutput` instead of a plain tuple.

Examples:

```python
>>> from transformers import PatchTSTConfig, PatchTSTForRegression

>>> # Regression task with 6 input channels and regress 2 targets
>>> model = PatchTSTForRegression.from_pretrained("namctin/patchtst_etth1_regression")

>>> # during inference, one only provides past values, the model outputs future values
>>> past_values = torch.randn(20, 512, 6)
>>> outputs = model(past_values=past_values)
>>> regression_outputs = outputs.regression_outputs
```NTrØ  c              3   ón   >#   • U  H*  oR                  S TR                  R                  5      v •  M,     g7f)r!   N)rS   r<   rí  )r¾  ÚitemrI   s     €r1   rÀ  Ú0PatchTSTForRegression.forward.<locals>.<genexpr>c  s)   øé € ÐWÒQVÈŸi™i¨¨D¯K©K×,CÑ,C×DÐDÒQVùs   ƒ25r<  rÚ  r   rÆ   )r`  rd  rL   rQ  )r<   r»  rù   rÕ  rP  r  r  rk   rr  r~  r   rÝ  rc  rL   rQ  )rI   rÁ   rý  r¹  rN  rN   r»  r   rÞ  r   r`  r  rõ   s   `            r1   r`   ÚPatchTSTForRegression.forward,  s  ø€ ðL &1Ñ%<‘kÀ$Ç+Á+×BYÑBYˆà—z‘zØ#Ø1Ø!5Ø/Øð "ð 
ˆð —	‘	˜,×8Ñ8Ó9ˆàˆØÑ$Ø×'×'Ø#×7Ñ7×DÑDÀUÓK�äÔWÑQVÓWÓW�Ü˜<Ó7�ä'¨Ó-‘ä—z’z¨FÑ3�Ù˜EÓ1�æà�h ¨a°Ð!3Ñ3ˆGØ+/Ñ+;�t�g Ñ'ˆGØˆNð BIˆGØˆNÜ*ØØ$Ø&×4Ñ4Ø#×.Ñ.ñ	
ð 	
r3   c                 óh  • U R                   R                  nU " USUSS9nU R                  R                  UR                  5      n[        U5       Vs/ s H  oeR                  5       PM     nn[        R                  " USS9R                  SX0R                   R                  5      n[        US9$ s  snf )a:  
Generate sequences of sample predictions from a model with a probability distribution head.

Parameters:
    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.
    past_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:
    [`SamplePatchTSTOutput`] where the outputs `sequences` tensor will have shape `(batch_size, number of
    samples, num_targets)`.
NF)rÁ   rý  r¹  rN  r   r$   r!   r"  )r<   r#  r  r  rd  r!  r$  r)   r$  rS   rí  rl  r%  s           r1   r'  ÚPatchTSTForRegression.generatew  s¦   € ð0  $Ÿ{™{×?Ñ?Ðñ Ø#ØØ1Ø!&ñ	
ˆð ×/Ñ/×<Ñ<¸W×=WÑ=WÓXˆä27Ð8LÔ2MÓNÒ2M¨Q×&Ñ&Ö(Ñ2MˆÐNä—+’+˜g¨1Ñ-×2Ñ2°2Ð7KÏ[É[×MdÑMdÓeˆÜ#¨gÑ6Ð6ùò Os   ÁB/r)  rÇ  rÌ   )rb   rc   rd   re   r   rA   r   r)   rj   ri   rk   rc  r`   r  rl  r'  rl   rm   rn   s   @r1   r4  r4    sò   ø† ð˜~÷ ð4 ð .2Ø26Ø,0Ø)-Ø#'ñH
à—\‘\ðH
ð —|‘| dÑ*ðH
ð "ŸL™L¨4Ñ/ð	H
ð
 # T™kðH
ð   $™;ðH
ð ˜D‘[ðH
ð 
Ð,Ñ	,ôH
ó ðH
ðT ‡]‚]ƒ_ð 37ñ'7à—\‘\ð'7ð "ŸL™L¨4Ñ/ð'7ð 
ô	'7ó ö'7r3   r4  )r²  rø   r  rÓ  r4  r÷  )NrQ   )NFr   rË  rW  )Prf   r8  Úcollections.abcr   Údataclassesr   r)   r   Ú r   r  Úactivationsr   Úintegrations.deepspeedr	   Úmodeling_flash_attention_utilsr
   Úmodeling_outputsr   Úmodeling_utilsr   r   Úprocessing_utilsr   Útime_series_utilsr   r   r   Úutilsr   r   r   r   Úconfiguration_patchtstr   Ú
get_loggerrb   rú  r  rj   rh   r2   r5   rp   Úlistri   rg   rš   rµ   r·   rÊ   rØ   rø   r  rÿ   r  rZ  r_  rc  rf  ri  rl  ÚdistributionsÚDistributionrr  r~  r€  r“  r£  rª  r²  rÉ  rÓ  rå  r÷  r  r  r+  r4  Ú__all__rž   r3   r1   Ú<module>rO     sá  ðñ ã Ý $Ý !ã Ý å &Ý "Ý @Ý BÝ /ß FÝ &ß UÑ Uß MÓ MÝ 2ð 
×	Ò	˜HÓ	%€ð !Øñ%Ø�I‰Ið%à�<‰<ð%ð 
�‰ð%ð �<‰<ð	%ð
 —L‘L 4Ñ'ð%ð �T‰\ð%ð ð%ð Ð'Ñ(õ%ô:R)˜Ÿ	™	ô R)ôj&˜Ÿ	™	ô &ð2 -1Ø',Øñ7%Ø�L‰Lð7%àð7%ð # T™kð7%ð !%ð	7%ð
 õ7%ðz -1Øñ	A%Ø�L‰LðA%à# c™zðA%ð # T™kðA%ð õ	A%ôH-�r—y‘yô -ô`9"�b—i‘iô 9"ôxF˜2Ÿ9™9ô FðR ô&2˜oó &2ó ð&2ôR!˜Ÿ	™	ô !ôH5 §¡ô 5ôp<xÐ-ô <xñ~ ðñð
 ô1˜+ó 1ó óð1ñ6 ðñð
 ô7 ;ó 7ó óð7ñ ðñð
 ô7 +ó 7ó óð7ñ ðñð
 ô+ +ó +ó óð+ñ4 ðñð
 ô7 kó 7ó óð7ñ ðñð ô/˜;ó /ó óð/ð#ˆu×"Ñ"×/Ñ/ð #¸¿¹ð #È%Ï,É,ô #ñ* 5§<¡<ð *¸%¿,¹,ÈÑ:Mð *Ðch×coÑcoõ *ô2 0˜Ÿ	™	ô  0ôH3;˜Ÿ™ô 3;ôn ˜Ÿ	™	ô  ô6 �R—Y‘Yô  ð8 ôn
Ð+ó n
ó ðn
ôb˜rŸy™yô ñ8 ðñô
m
Ð4ó m
óð
m
ô`" §¡ô "ñJ ðñô
U
Ð 7ó U
óð
U
ñp ðñô
]˜RŸY™Yó ]óð
]ñ@ ðñô
z7Ð3ó z7óð
z7ôz4˜RŸY™Yô 4ñn ðñô
N7Ð3ó N7óð
N7òb�r3   