Ë
    Ï—¬jÙ  ã                   ó˜   — d dl mZmZ d dlmZ d dlmZmZ d dlZd dl	m
Z
 d dlZd dlmZ  G d„ dej                  j                  e«      Zy)	é    )ÚABCÚabstractmethod)ÚSequence)ÚTYPE_CHECKINGÚfinalN)Ú	rearrange)Úprofilec            
       ó>  ‡ — e Zd ZU dZeed<   dZeed<   ej                  ed<   e
ˆ fd„«       Ze
dej                  dej                  d	d
fd„«       Zedej                  dej                  ded	ed   fd„«       Ze
dd„«       Ze
dej                  dej                  d	eej                     fd„«       Zedej                  dedefd„«       Zedej                  dedefd„«       Zedej                  defd„«       Zdej                  deded	ej                  fd„Zˆ xZS )Ú	LinearABCFÚ_fittedr   Ú
_n_samplesÚ
_x_lag_bufc                ó"   •— t         ‰| �  «        y )N)ÚsuperÚ__init__)ÚselfÚkwargsÚ	__class__s     €ún/root/disk_3tb/EEG-sAAD-Grand-Challenge-Training-Dataset/SuperHugeAAD/superhuge/model/linear/regression/abc.pyr   zLinearABC.__init__   s   ø€ ä‰ÑÕó    ÚeegÚenvÚreturnNc                 óh   — | xj                   |j                  d   |j                  d   z  z  c_         y)z1
        Update the model with new data.
        r   é   N)r   Úshape)r   r   r   r   s       r   ÚupdatezLinearABC.update   s'   € ð
 	�Š˜3Ÿ9™9 Q™<¨#¯)©)°A©,Ñ6Ñ6Žr   Úmeta)zsuperhuge.model.types.EEG_TYPEz superhuge.model.types.AUDIO_TYPEc                 ó”   — | j                   r| j                  ||«      \  }}||fS | j                  r| j                  |||¬«       ||fS )z,
        Forward pass of the model.
        )r   )r   ÚpredictÚtrainingr   )r   r   r   r   s       r   ÚforwardzLinearABC.forward   sN   € ð �<Š<Ø—|‘| C¨Ó-‰HˆC�ð �Cˆxˆð �]Š]Ø�K‰K˜˜S tˆKÔ,Ø�Cˆxˆr   c                  ó   — y)z,
        Fit the model to the data.
        N© )r   s    r   ÚfitzLinearABC.fit)   ó   € ð
 	r   c                  ó   — y)z=
        Predict the output based on the input data.
        Nr$   )r   r   r   s      r   r    zLinearABC.predict0   r&   r   ÚxÚstartÚendc                 óF  — |j                   ^}}}||z
  dz   }|||g|¢­}t        | d«      r| j                  j                   |k7  r/| j                  dt	        j
                  |d|j                  iŽ«       | j                  }	|	j                  «        t        t        ||dz   «      «      D ]v  \  }
}|dk  r|dd…d||z   …df   |	dd…| d…|
dd…f<   Œ)|dkD  r|dd…|d…df   |	dd…d||z
  …|
dd…f<   ŒK|	dd…dd…|
dd…f   j                  |j                  «       «       Œx |	S )u¹  
        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Úemptyr,   Úzero_Ú	enumerateÚrangeÚcopy_Údetach)r   r(   r)   r*   ÚbatchÚtimeÚrestÚnlagÚ
need_shapeÚbufÚlag_idxÚshifts               r   Úget_lag_mtx_rangezLinearABC.get_lag_mtx_range7   s1  € ð, ŸW™WÐˆˆt�dØ�U‰{˜Q‰ˆà˜T 4Ð/¨$Ñ/ˆ
Ü�t˜\Ô*¨d¯o©o×.CÑ.CÀzÒ.QØ× Ñ ØÜ—‘˜ZÐ9°·±Ñ9ôð
 �o‰oˆØ�	‰	Œä'¬¨e°S¸1±WÓ(=Ö>‰NˆG�UØ�qŠyØ./²°>°T¸E±\°>À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                 ó*   — | j                  || |«      S )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.
        )r>   )r   r(   r?   r@   s       r   Úget_lag_mtxzLinearABC.get_lag_mtxe   s   € ð ×%Ñ% a¨'¨°8Ó<Ð<r   Úlagc                 ó²  — g }|\  }}|dk  r| }|dk\  sJ d«       ‚|dk\  sJ d«       ‚t        | |dz   «      D �]  }|dk  r„|j                  t        j                  t        j                  |j
                  d   | g|j
                  dd ¢­«      j                  |«      |dd…d|j
                  d   |z   …f   gd¬«      «       Œ�|dkD  sŒ“|j                  t        j                  |dd…|d…dd…f   t        j                  |j
                  d   |g|j
                  dd ¢­Ž j                  |«      gd¬«      «       �Œ t        j                  |d¬«      }|S )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)r3   Úappendr/   ÚcatÚzerosr   Útype_asÚstack)r   r(   rC   r   Úx_lagr?   r@   Úls           r   Úget_lag_mtx_oldzLinearABC.get_lag_mtx_oldn   sa  € ð ˆØÑˆ�Ø�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                 óL   — | j                  ||d   |d   «      }t        ||«      S )a/  
        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   )r>   r   )r   rO   rP   rQ   Úlagged_matrixs        r   Úlag_and_flattenzLinearABC.lag_and_flattenž   s4   € ð ×.Ñ.¨v°{À1±~À{ÐSTÁ~ÓVˆÜØØó
ð 	
r   )r   N)Ú__name__Ú
__module__Ú__qualname__r   ÚboolÚ__annotations__r   Úintr/   ÚTensorr   r   r   r   ÚdictÚtupler"   r%   r   r    r>   rB   rN   ÚstrrT   Ú__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   r/   Úeinopsr   Ú	superhugeÚmemory_profilerr	   ÚnnÚModuler   r$   r   r   Ú<module>rh      s2   ðß #Ý $ß 'Û Ý ã å #ôd
�—‘—‘ õ d
r   