ó
    Ï—¬jÙ  ã                   ó˜   • S SK JrJr  S SKJr  S SKJrJr  S SKrS SK	J
r
  S SKrS SKJr   " S S\R                  R                  \5      rg)	é    )ÚABCÚabstractmethod)ÚSequence)ÚTYPE_CHECKINGÚfinalN)Ú	rearrange)Úprofilec            
       óX  ^ • \ rS rSr% Sr\\S'   Sr\\S'   \	R                  \S'   \U 4S j5       r\S\	R                  S	\	R                  S
S4S j5       r\S\	R                  S	\	R                  S\S
\S   4S j5       r\S S j5       r\S\	R                  S	\	R                  S
\\	R                     4S j5       r\S\	R                  S\S\4S j5       r\S\	R                  S\S\4S j5       r\S\	R                  S\4S j5       rS\	R                  S\S\S
\	R                  4S jrSrU =r$ )!Ú	LinearABCé   FÚ_fittedr   Ú
_n_samplesÚ
_x_lag_bufc                ó"   >• [         TU ]  5         g )N)ÚsuperÚ__init__)ÚselfÚkwargsÚ	__class__s     €Ú/root/disk_3tb/EEG-sAAD-Grand-Challenge-Training-Dataset/baselines/python/SuperHugeAAD/superhuge/model/linear/regression/abc.pyr   ÚLinearABC.__init__   s   ø€ ä‰ÑÕó    ÚeegÚenvÚreturnNc                 óh   • U =R                   UR                  S   UR                  S   -  -  sl         g)z!
Update the model with new data.
r   é   N)r   Úshape)r   r   r   r   s       r   ÚupdateÚLinearABC.update   s'   € ð
 	�Š˜3Ÿ9™9 Q™<¨#¯)©)°A©,Ñ6Ñ6Žr   Úmeta)zsuperhuge.model.types.EEG_TYPEz superhuge.model.types.AUDIO_TYPEc                 ó˜   • U R                   (       a  U R                  X5      u  pX4$ U R                  (       a  U R                  XUS9  X4$ )z
Forward pass of the model.
)r!   )r   ÚpredictÚtrainingr   )r   r   r   r!   s       r   ÚforwardÚLinearABC.forward   sD   € ð �<�<Ø—|‘| CÓ-‰HˆCð ˆxˆð �]�]Ø�K‰K˜ tˆKÑ,Øˆxˆr   c                 ó   • g)z
Fit the model to the data.
N© )r   s    r   ÚfitÚLinearABC.fit)   ó   € ð
 	r   c                 ó   • g)z-
Predict the output based on the input data.
Nr(   )r   r   r   s      r   r#   ÚLinearABC.predict0   r+   r   ÚxÚstartÚendc                 óR  • UR                   tpEnX2-
  S-   nXEU/UQ7n[        U S5      (       a  U R                  R                   U:w  a0  U R                  S[        R
                  " USUR                  065        U R                  n	U	R                  5         [        [        X#S-   5      5       Hx  u  p«US:  a  USS2SX[-   2S4   U	SS2U* S2U
SS24'   M)  US:”  a  USS2US2S4   U	SS2SX[-
  2U
SS24'   ML  U	SS2SS2U
SS24   R                  UR                  5       5        Mz     U	$ )uA  
Fill a single pre-allocated buffer with lagged copies of x over the
arbitrary shift range ``[start, end]`` (samples). Negative shifts take
PAST samples (x(t-|s|), causal), positive shifts take FUTURE samples
(x(t+s), non-causal); shift 0 takes the current sample.

``[start, end]`` generalises the legacy ``pre_lag/post_lag`` pair:
``get_lag_mtx(x, pre, post) == get_lag_mtx_range(x, -pre, post)``.

Returns view â€” zero allocation per call.

Buffer layout: (batch, time, nlag, ch_flat), contiguous.
This layout means merge patterns like
    "batch time lag channel -> (batch time) (lag channel)"
are pure views (both batch-time and lag-channel are adjacent in memory).

Old layout was (batch, nlag, time, ...) â€” that layout required
a copy for every einops rearrange because batch and time were
separated by the nlag dimension.
r   r   Údevicer   N.)r   Úhasattrr   Úregister_bufferÚtorchÚemptyr2   Úzero_Ú	enumerateÚrangeÚcopy_Údetach)r   r.   r/   r0   ÚbatchÚtimeÚrestÚnlagÚ
need_shapeÚbufÚlag_idxÚshifts               r   Úget_lag_mtx_rangeÚLinearABC.get_lag_mtx_range7   s&  € ð, ŸW™WÐˆ�dØ‰{˜Q‰ˆà 4Ð/¨$Ñ/ˆ
Ü�t˜\×*Ñ*¨d¯o©o×.CÑ.CÀzÓ.QØ× Ñ ØÜ—’˜ZÐ9°·±Ñ9ôð
 �o‰oˆØ�	‰	Œä'¬¨e¸1±WÓ(=Ö>‰NˆGØ�q‹yØ./²°>°T±\°>À3Ð0FÑ.G�’A˜�v‘w ªÐ*Ó+Ø˜“Ø56²q¸%¹&À#°~Ñ5F�’A�~˜™�~ w²Ð1Ó2ð ’A’q˜'¢1Ð$Ñ%×+Ñ+¨A¯H©H«JÖ7ñ ?ð ˆ
r   Úpre_lagÚpost_lagc                 ó(   • U R                  X* U5      $ )uÄ   
Legacy lagged-matrix builder: shift range [âˆ’pre_lag, +post_lag] (samples).
Equivalent to ``get_lag_mtx_range(x, -pre_lag, post_lag)``; kept with
unchanged semantics for backward compatibility.
)rD   )r   r.   rF   rG   s       r   Úget_lag_mtxÚLinearABC.get_lag_mtxe   s   € ð ×%Ñ% a¨°8Ó<Ð<r   Úlagc                 óº  • / nUu  pVUS:  a  U* nUS:¼  d   S5       eUS:¼  d   S5       e[        U* US-   5       GH  nUS::  a„  UR                  [        R                  " [        R                  " UR
                  S   U* /UR
                  SS Q75      R                  U5      USS2SUR
                  S   U-   24   /SS95        MŽ  US:”  d  M–  UR                  [        R                  " USS2US2SS24   [        R                  " UR
                  S   U/UR
                  SS Q76 R                  U5      /SS95        GM
     [        R                  " USS9nU$ )a‰  
Construct a lagged matrix for the input with given lag.

Parameters:
x: torch.Tensor, input tensor. Shape: (batch_size, time_steps, ...). The lag (or advance) is operated along the time dimension, and lagged signals is inseted into the second dimension. Other dimensions remain unchanged.
pre_lag: int, number of time steps to advance. The mathematical formula is y(t) = sum_n w(n)*x(t-n)
post_lag: int, number of time steps to lag. The mathematical formula is y(t) = sum_n w(n)*x(t+n)

Example:
lag: 10, 10. return: (batch_size, 21, time_steps, ...). 10 means the input is advanced by 10 time steps, 10 means the input is lagged by 10 time steps.
r   zpre_lag must be non-negativezpost_lag must be non-negativer   é   N)Údim)r9   Úappendr5   ÚcatÚzerosr   Útype_asÚstack)r   r.   rK   r   Úx_lagrF   rG   Úls           r   Úget_lag_mtx_oldÚLinearABC.get_lag_mtx_oldn   s_  € ð ˆØÑˆØ�Q‹;Ø�hˆGà˜!‹|Ð;Ð;Ó;ˆ|Ø˜1‹}Ð=Ð=Ó=ˆ}ä˜�x ¨A¡×.ˆAØ�A‹vØ—‘Ü—I’Iä!ŸKšK¨¯©°©°a°RÐ(F¸!¿'¹'À!À"¸+Ñ(FÓG×OÑOÐPQÓRØšaÐ!1 1§7¡7¨1¡:°¡>Ð!1Ð1Ñ2ðð ñöð �Q•Ø—‘Ü—I’Iàša ¡¢Q˜h™KÜ!ŸKšK¨¯©°©
°AÐD¸¿¹ÀÀ¸ÒD×LÑLÈQÓOðð ñ÷ñ /ô* —’ØØñ
ˆð ˆr   ÚsignalÚpatternÚlag_samplesc                 óJ   • U R                  XS   US   5      n[        UU5      $ )zï
Create lagged matrix and flatten it.

Args:
    signal: Input tensor [batch, time, features]
    lag_samples: Number of lag samples
    num_features: Number of features

Returns:
    Flattened lagged matrix [batch * time, lag * features]
r   r   )rD   r   )r   rX   rY   rZ   Úlagged_matrixs        r   Úlag_and_flattenÚLinearABC.lag_and_flattenž   s2   € ð ×.Ñ.¨vÀ1±~À{ÐSTÁ~ÓVˆÜØØó
ð 	
r   r(   )r   N)Ú__name__Ú
__module__Ú__qualname__Ú__firstlineno__r   ÚboolÚ__annotations__r   Úintr5   ÚTensorr   r   r   r   ÚdictÚtupler%   r)   r   r#   rD   rI   rV   Ústrr]   Ú__static_attributes__Ú__classcell__)r   s   @r   r   r      s¨  ø‡ Ø€GˆTÓØ€J�ÓØ—‘Óàôó ðð ð7˜%Ÿ,™,ð 7¨U¯\©\ð 7Èó 7ó ð7ð ð
Ø—<‘<ð
Ø&+§l¡lð
Ø:>ð
à	ÐSÑ	Tó
ó ð
ð óó ðð ð˜5Ÿ<™<ð ¨e¯l©lð ¸xÈÏÉÑ?Uó ó ðð ð+ 5§<¡<ð +¸ð +À#ó +ó ð+ðZ ð=˜UŸ\™\ð =°Cð =À3ó =ó ð=ð ð- §¡ð -°Só -ó ð-ð^
Ø—l‘lð
Ø-0ð
Ø@Cð
à	�‰÷
ò 
r   r   )Úabcr   r   Úcollections.abcr   Útypingr   r   r5   Úeinopsr   Ú	superhugeÚmemory_profilerr	   ÚnnÚModuler   r(   r   r   Ú<module>rt      s2   ðß #Ý $ß 'Û Ý ã å #ôd
�—‘—‘ õ d
r   