U
    CŒÑhb•  ã                   @   s|  d dl Z d dlZd dlmZmZmZmZ d dlZd dlmZ d dl	m
Z G dd„ dejjƒZG dd„ dejjƒZG d	d
„ d
ejjƒZG dd„ dejjƒZG dd„ dejjƒZG dd„ dejjƒZG dd„ dejƒZG dd„ dejƒZejeeejdœdd„Zdd„ Zd(ejeeeejdœdd„Zd)ejeeeejdœdd „Zee ed!œd"d#„Zee ed!œd$d%„Zee ed!œd&d'„ZdS )*é    N)ÚAnyÚDictÚListÚOptional)Únn)Ú
functionalc                       sV   e Zd ZdZdeeeedœ‡ fdd„Zee	j
dœdd	„ƒZe	j
e	j
d
œdd„Z‡  ZS )Ú_ScaledEmbeddingaF  Make continuous embeddings and boost learning rate

    Args:
        num_embeddings (int): number of embeddings
        embedding_dim (int): embedding dimensions
        scale (float, optional): amount to scale learning rate (Default: 10.0)
        smooth (bool, optional): choose to apply smoothing (Default: ``False``)
    ç      $@F)Únum_embeddingsÚembedding_dimÚscaleÚsmoothc                    s‚   t ƒ  ¡  t ||¡| _|rftj| jjjdd�}|t 	d|d ¡ 
¡ d d …d f  }|| jjjd d …< | jj j|  _|| _d S )Nr   ©Údimé   )ÚsuperÚ__init__r   Z	EmbeddingÚ	embeddingÚtorchZcumsumÚweightÚdataÚarangeÚsqrtr   )Úselfr
   r   r   r   r   ©Ú	__class__© úH/tmp/user/2202/pip-unpacked-wheel-p89lpdx5/torchaudio/models/_hdemucs.pyr   -   s    
$z_ScaledEmbedding.__init__)Úreturnc                 C   s   | j j| j S ©N)r   r   r   )r   r   r   r   r   8   s    z_ScaledEmbedding.weight©Úxr   c                 C   s   |   |¡| j }|S )zøForward pass for embedding with scale.
        Args:
            x (torch.Tensor): input tensor of shape `(num_embeddings)`

        Returns:
            (Tensor):
                Embedding output of shape `(num_embeddings, embedding_dim)`
        )r   r   )r   r!   Úoutr   r   r   Úforward<   s    	z_ScaledEmbedding.forward)r	   F)Ú__name__Ú
__module__Ú__qualname__Ú__doc__ÚintÚfloatÚboolr   Úpropertyr   ÚTensorr   r#   Ú__classcell__r   r   r   r   r   #   s
   	r   c                       sf   e Zd ZdZdeeeeeeeeeeeee	f  ed	œ‡ fd
d„Z
dejeej ejdœdd„Z‡  ZS )Ú
_HEncLayerat  Encoder layer. This used both by the time and the frequency branch.
    Args:
        chin (int): number of input channels.
        chout (int): number of output channels.
        kernel_size (int, optional): Kernel size for encoder (Default: 8)
        stride (int, optional): Stride for encoder layer (Default: 4)
        norm_groups (int, optional): number of groups for group norm. (Default: 4)
        empty (bool, optional): used to make a layer with just the first conv. this is used
            before merging the time and freq. branches. (Default: ``False``)
        freq (bool, optional): boolean for whether conv layer is for frequency domain (Default: ``True``)
        norm_type (string, optional): Norm type, either ``group_norm `` or ``none`` (Default: ``group_norm``)
        context (int, optional): context size for the 1x1 conv. (Default: 0)
        dconv_kw (Dict[str, Any] or None, optional): dictionary of kwargs for the DConv class. (Default: ``None``)
        pad (bool, optional): true to pad the input. Padding is done so that the output size is
            always the input size / stride. (Default: ``True``)
    é   é   FTÚ
group_normr   N)ÚchinÚchoutÚkernel_sizeÚstrideÚnorm_groupsÚemptyÚfreqÚ	norm_typeÚcontextÚdconv_kwÚpadc                    s  t ƒ  ¡  |
d kri }
dd„ }|dkr2‡ fdd„}|r>|d nd}tj}|| _|| _|| _|| _|| _|rˆ|dg}|dg}|dg}tj	}||||||ƒ| _
||ƒ| _| jrÊt ¡ | _t ¡ | _t ¡ | _n:||d| dd|	  d|	ƒ| _|d| ƒ| _t|f|
Ž| _d S )	Nc                 S   s   t  ¡ S r   ©r   ÚIdentity©Údr   r   r   Ú<lambda>m   ó    z%_HEncLayer.__init__.<locals>.<lambda>r1   c                    s   t  ˆ | ¡S r   ©r   Z	GroupNormr?   ©r6   r   r   rA   o   rB   r0   r   r   é   )r   r   r   ÚConv1dr8   r4   r5   r7   r<   ÚConv2dÚconvÚnorm1r>   ÚrewriteÚnorm2ÚdconvÚ_DConv)r   r2   r3   r4   r5   r6   r7   r8   r9   r:   r;   r<   Únorm_fnZpad_valÚklassr   rD   r   r   \   s6    



z_HEncLayer.__init__)r!   Úinjectr   c           
      C   sj  | j s.| ¡ dkr.|j\}}}}| |d|¡}| j sh|jd }|| j dksht |d| j|| j  f¡}|  |¡}| jr||S |dk	rÖ|jd |jd kr t	dƒ‚| ¡ dkrÎ| ¡ dkrÎ|dd…dd…df }|| }t 
|  |¡¡}| j �r>|j\}}}}| dddd¡ d||¡}|  |¡}| ||||¡ dddd¡}n
|  |¡}|  |  |¡¡}	tj|	dd	�}	|	S )
a]  Forward pass for encoding layer.

        Size depends on whether frequency or time

        Args:
            x (torch.Tensor): tensor input of shape `(B, C, F, T)` for frequency and shape
                `(B, C, T)` for time
            inject (torch.Tensor, optional): on last layer, combine frequency and time branches through inject param,
                same shape as x (default: ``None``)

        Returns:
            Tensor
                output tensor after encoder layer of shape `(B, C, F / stride, T)` for frequency
                    and shape `(B, C, ceil(T / stride))` for time
        r0   éÿÿÿÿr   NzInjection shapes do not aligné   rE   r   r   )r8   r   ÚshapeÚviewr5   ÚFr<   rH   r7   Ú
ValueErrorÚgelurI   ÚpermuteÚreshaperL   rK   rJ   Úglu)
r   r!   rP   ÚBÚCÚFrÚTÚleÚyÚzr   r   r   r#   ˆ   s4    



z_HEncLayer.forward)	r/   r0   r0   FTr1   r   NT)N©r$   r%   r&   r'   r(   r*   Ústrr   r   r   r   r   r,   r#   r-   r   r   r   r   r.   I   s0            ôô,r.   c                       sb   e Zd ZdZdeeeeeeeeeeeeee	f  ed	œ‡ fd
d„Z
ejeej dœdd„Z‡  ZS )Ú
_HDecLayera»  Decoder layer. This used both by the time and the frequency branches.
    Args:
        chin (int): number of input channels.
        chout (int): number of output channels.
        last (bool, optional): whether current layer is final layer (Default: ``False``)
        kernel_size (int, optional): Kernel size for encoder (Default: 8)
        stride (int): Stride for encoder layer (Default: 4)
        norm_groups (int, optional): number of groups for group norm. (Default: 1)
        empty (bool, optional): used to make a layer with just the first conv. this is used
            before merging the time and freq. branches. (Default: ``False``)
        freq (bool, optional): boolean for whether conv layer is for frequency (Default: ``True``)
        norm_type (str, optional): Norm type, either ``group_norm `` or ``none`` (Default: ``group_norm``)
        context (int, optional): context size for the 1x1 conv. (Default: 1)
        dconv_kw (Dict[str, Any] or None, optional): dictionary of kwargs for the DConv class. (Default: ``None``)
        pad (bool, optional): true to pad the input. Padding is done so that the output size is
            always the input size / stride. (Default: ``True``)
    Fr/   r0   r   Tr1   N)r2   r3   Úlastr4   r5   r6   r7   r8   r9   r:   r;   r<   c                    s  t ƒ  ¡  |d kri }dd„ }|	dkr2‡ fdd„}|r\|| d dkrNtdƒ‚|| d }nd}|| _|| _|| _|| _|| _|| _|| _	t
j}t
j}|r¶|dg}|dg}t
j}t
j}|||||ƒ| _||ƒ| _| jrìt
 ¡ | _t
 ¡ | _n,||d| dd|
  d|
ƒ| _|d| ƒ| _d S )	Nc                 S   s   t  ¡ S r   r=   r?   r   r   r   rA   Ü   rB   z%_HDecLayer.__init__.<locals>.<lambda>r1   c                    s   t  ˆ | ¡S r   rC   r?   rD   r   r   rA   Þ   rB   rE   r   z#Kernel size and stride do not alignr   )r   r   rV   r<   re   r8   r2   r7   r5   r4   r   rF   ÚConvTranspose1drG   ÚConvTranspose2dÚconv_trrK   r>   rJ   rI   )r   r2   r3   re   r4   r5   r6   r7   r8   r9   r:   r;   r<   rN   rO   Zklass_trr   rD   r   r   Ê   s@    


z_HDecLayer.__init__)r!   Úskipc           	      C   sî   | j r0| ¡ dkr0|j\}}}| || jd|¡}| jsZ|| }tj|  |  	|¡¡dd�}n|}|dk	rnt
dƒ‚|  |  |¡¡}| j r¨| jrÖ|d| j| j …dd…f }n.|d| j| j| …f }|jd |krÖt
dƒ‚| jsæt |¡}||fS )	a,  Forward pass for decoding layer.

        Size depends on whether frequency or time

        Args:
            x (torch.Tensor): tensor input of shape `(B, C, F, T)` for frequency and shape
                `(B, C, T)` for time
            skip (torch.Tensor, optional): on first layer, separate frequency and time branches using param
                (default: ``None``)
            length (int): Size of tensor for output

        Returns:
            (Tensor, Tensor):
                Tensor
                    output tensor after decoder layer of shape `(B, C, F * stride, T)` for frequency domain except last
                        frequency layer shape is `(B, C, kernel_size, T)`. Shape is `(B, C, stride * T)`
                        for time domain.
                Tensor
                    contains the output just before final transposed convolution, which is used when the
                        freq. and time branch separate. Otherwise, does not matter. Shape is
                        `(B, C, F, T)` for frequency and `(B, C, T)` for time.
        rR   rQ   r   r   Nz%Skip must be none when empty is true..z'Last index of z must be equal to length)r8   r   rS   rT   r2   r7   rU   rZ   rI   rJ   rV   rK   rh   r<   re   rW   )	r   r!   ri   Úlengthr[   r\   r^   r`   ra   r   r   r   r#   ü   s&    
z_HDecLayer.forward)
Fr/   r0   r   FTr1   r   NTrb   r   r   r   r   rd   ·   s4             óó2rd   c                       s    e Zd ZdZd"ee eeeeeeeeeeeeeeeeeeeedœ‡ fdd„Z	dd„ Z
d#dd„Zd$ejeeeedœdd„Zdd„ Zdd„ Zejdœd d!„Z‡  ZS )%ÚHDemucsa#
  Hybrid Demucs model from
    *Hybrid Spectrogram and Waveform Source Separation* :cite:`defossez2021hybrid`.

    See Also:
        * :class:`torchaudio.pipelines.SourceSeparationBundle`: Source separation pipeline with pre-trained models.

    Args:
        sources (List[str]): list of source names. List can contain the following source
            options: [``"bass"``, ``"drums"``, ``"other"``, ``"mixture"``, ``"vocals"``].
        audio_channels (int, optional): input/output audio channels. (Default: 2)
        channels (int, optional): initial number of hidden channels. (Default: 48)
        growth (int, optional): increase the number of hidden channels by this factor at each layer. (Default: 2)
        nfft (int, optional): number of fft bins. Note that changing this requires careful computation of
            various shape parameters and will not work out of the box for hybrid models. (Default: 4096)
        depth (int, optional): number of layers in encoder and decoder (Default: 6)
        freq_emb (float, optional): add frequency embedding after the first frequency layer if > 0,
            the actual value controls the weight of the embedding. (Default: 0.2)
        emb_scale (int, optional): equivalent to scaling the embedding learning rate (Default: 10)
        emb_smooth (bool, optional): initialize the embedding with a smooth one (with respect to frequencies).
            (Default: ``True``)
        kernel_size (int, optional): kernel_size for encoder and decoder layers. (Default: 8)
        time_stride (int, optional): stride for the final time layer, after the merge. (Default: 2)
        stride (int, optional): stride for encoder and decoder layers. (Default: 4)
        context (int, optional): context for 1x1 conv in the decoder. (Default: 4)
        context_enc (int, optional): context for 1x1 conv in the encoder. (Default: 0)
        norm_starts (int, optional): layer at which group norm starts being used.
            decoder layers are numbered in reverse order. (Default: 4)
        norm_groups (int, optional): number of groups for group norm. (Default: 4)
        dconv_depth (int, optional): depth of residual DConv branch. (Default: 2)
        dconv_comp (int, optional): compression of DConv branch. (Default: 4)
        dconv_attn (int, optional): adds attention layers in DConv branch starting at this layer. (Default: 4)
        dconv_lstm (int, optional): adds a LSTM layer in DConv branch starting at this layer. (Default: 4)
        dconv_init (float, optional): initial scale for the DConv branch LayerScale. (Default: 1e-4)
    rE   é0   é   é   çš™™™™™É?é
   Tr/   r0   r   r   ç-Cëâ6?)ÚsourcesÚaudio_channelsÚchannelsÚgrowthÚnfftÚdepthÚfreq_embÚ	emb_scaleÚ
emb_smoothr4   Útime_strider5   r:   Úcontext_encÚnorm_startsr6   Údconv_depthÚ
dconv_compÚ
dconv_attnÚ
dconv_lstmÚ
dconv_initc           +         sØ  t ƒ  ¡  || _|| _|| _|| _|
| _|| _|| _|| _	| jd | _
d | _t ¡ | _t ¡ | _t ¡ | _t ¡ | _|}|d }|}|}| jd }t| jƒD �],}||k}||k}||kr¾dnd}|dk}|} |
}!|sò|dkrætdƒ‚|d }!|} d}"d}#|�r||
k�r|}!d}"d}#|!| ||"|||||||d	œd
œ}$t|$ƒ}%d|%d< |
|%d< ||%d< d|%d< t|$ƒ}&|#�rzt||ƒ}|}t||fd|i|$—Ž}'|�rÞ|#dk�rº|dk�rºd|%d< d|%d< t||f||#dœ|%—Ž}(| j |(¡ | j |'¡ |dk�r| jt| jƒ }|d }t||f|dk|dœ|&—Ž})|�rZt||f|#|dk|dœ|%—Ž}*| j d|*¡ | j d|)¡ |}|}t|| ƒ}t|| ƒ}|�r¦||
k�ržd}n|| }|dkrœ|rœt|||	|d�| _|| _qœt| ƒ d S )Nr0   rE   r1   Únoner   z$When freq is false, freqs must be 1.TF)ÚlstmÚattnrw   ÚcompressÚinit)r4   r5   r8   r<   r9   r6   r;   r   r8   r4   r5   r<   r:   é   )r:   r7   )re   r:   )r7   re   r:   )r   r   )r   r   rw   rv   rs   rr   r4   r:   r5   rt   Ú
hop_lengthrx   r   Ú
ModuleListÚfreq_encoderÚfreq_decoderÚtime_encoderÚtime_decoderÚrangerV   ÚdictÚmaxr.   ÚappendÚlenrd   Úinsertr(   r   Úfreq_emb_scaleÚ_rescale_module)+r   rr   rs   rt   ru   rv   rw   rx   ry   rz   r4   r{   r5   r:   r|   r}   r6   r~   r   r€   r�   r‚   r2   Zchin_zr3   Zchout_zÚfreqsÚindexr„   r…   r9   r8   ZstriZkerr<   Z	last_freqÚkwZkwtZkw_decÚencÚtencÚdecÚtdecr   r   r   r   Q  s°    





ûù


zHDemucs.__init__c                 C   s¼   | j }| j}|}||d kr$tdƒ‚tt |jd | ¡ƒ}|d d }| j|||||  |jd  dd�}t|||ƒdd d…d d …f }|jd |d kr¤td	ƒ‚|ddd| …f }|S )
Nr0   zHop length must be nfft // 4rQ   rE   rR   Úreflect)Úmode.zESpectrogram's last dimension must be 4 + input size divided by stride)	r‰   rv   rV   r(   ÚmathÚceilrS   Ú_pad1dÚ_spectro)r   r!   Úhlrv   Zx0r_   r<   ra   r   r   r   Ú_specÑ  s    	$zHDemucs._specNc                 C   sz   | j }t |ddddg¡}t |ddg¡}|d d }|tt || ¡ƒ d|  }t|||d�}|d||| …f }|S )Nr   r   rE   rR   )rj   .)r‰   rU   r<   r(   r    r¡   Ú	_ispectro)r   ra   rj   r¤   r<   r_   r!   r   r   r   Ú_ispecé  s    zHDemucs._ispecÚzeroç        )r!   Úpadding_leftÚpadding_rightrŸ   Úvaluec                 C   sP   |j d }|dkr<t||ƒ}||kr<t |d|| d f¡}t |||f||¡S )z¤Wrapper around F.pad, in order for reflect padding when num_frames is shorter than max_pad.
        Add extra zero padding around in order for padding to not break.rQ   rž   r   r   )rS   r‘   rU   r<   )r   r!   rª   r«   rŸ   r¬   rj   Zmax_padr   r   r   r¢   ó  s    

zHDemucs._pad1dc                 C   s>   |j \}}}}t |¡ ddddd¡}| ||d ||¡}|S )Nr   r   r0   rE   rR   )rS   r   Zview_as_realrX   rY   )r   ra   r[   r\   r]   r^   Úmr   r   r   Ú
_magnitudeý  s    zHDemucs._magnitudec                 C   sF   |j \}}}}}| ||dd||¡ dddddd¡}t | ¡ ¡}|S )NrQ   rE   r   r   r0   é   rR   )rS   rT   rX   r   Zview_as_complexÚ
contiguous)r   r­   r[   ÚSr\   r]   r^   r"   r   r   r   Ú_mask  s    $zHDemucs._mask)Úinputc           "      C   s†  |j dkrtd|j› �ƒ‚|jd | jkr@td|jd › d�ƒ‚|}|jd }|  |¡}|  |¡}|}|j\}}}}	|jddd	�}
|jddd	�}||
 d
|  }|}|jddd	�}|jddd	�}|| d
|  }g }g }g }g }t| j	ƒD ]Ü\}}| 
|jd ¡ d}|t| jƒk �rP| 
|jd ¡ | j| }||ƒ}|j�sL| 
|¡ n|}|||ƒ}|dk�r¼| jdk	�r¼tj|jd |jd�}|  |¡ ¡ ddd…dd…df  |¡}|| j|  }| 
|¡ qêt |¡}t |¡}t| jƒD ]Æ\}}| d¡}|||| d¡ƒ\}}| jt| jƒ }||k�ræ| j||  }| d¡}|j�r�|jd dk�rhtd|j› �ƒ‚|dd…dd…df }||d|ƒ\}}n| d¡}||||ƒ\}}�qæt|ƒdk�rÄtdƒ‚t|ƒdk�rÚtdƒ‚t|ƒdk�rðtdƒ‚t| jƒ} | || d||	¡}||dd…df  |
dd…df  }|  |¡}!|  |!|¡}| || d|¡}||dd…df  |dd…df  }|| }|S )a  HDemucs forward call

        Args:
            input (torch.Tensor): input mixed tensor of shape `(batch_size, channel, num_frames)`

        Returns:
            Tensor
                output tensor split into sources of shape `(batch_size, num_sources, channel, num_frames)`
        rR   zDExpected 3D tensor with dimensions (batch, channel, frames). Found: r   zZThe channel dimension of input Tensor must match `audio_channels` of HDemucs model. Found:Ú.rQ   )r   rE   rR   T)r   Zkeepdimgñhãˆµøä>)r   rE   Nr   éþÿÿÿ)ÚdevicerE   z0If tdec empty is True, pre shape does not match zsaved is not emptyzlengths_t is not emptyzsaved_t is not empty)ÚndimrV   rS   rs   r¥   r®   ÚmeanÚstdÚ	enumerater‹   r’   r“   r�   r7   rx   r   r   r¶   ÚtZ	expand_asr•   Z
zeros_likerŒ   Úpoprw   rŽ   ÚAssertionErrorrr   rT   r²   r§   )"r   r³   r!   rj   ra   Zmagr[   r\   ZFqr^   r¸   r¹   ZxtZmeantZstdtZsavedZsaved_tÚlengthsZ	lengths_tÚidxÚencoderP   r›   ZfrsZembÚdecoderi   ÚpreÚoffsetr�   Zlength_tÚ_r±   Zzoutr   r   r   r#     sŒ    
ÿ




(






$
$zHDemucs.forward)rE   rl   rE   rm   rn   ro   rp   Tr/   rE   r0   r   r   r0   r0   rE   r0   r0   r0   rq   )N)r¨   r©   )r$   r%   r&   r'   r   rc   r(   r)   r*   r   r¥   r§   r   r,   r¢   r®   r²   r#   r-   r   r   r   r   rk   -  sf   &                    êê 


rk   c                       sB   e Zd ZdZdeeeeeeeeeedœ
‡ fd	d
„Zdd„ Z	‡  Z
S )rM   a±  
    New residual branches in each encoder layer.
    This alternates dilated convolutions, potentially with LSTMs and attention.
    Also before entering each residual branch, dimension is projected on a smaller subspace,
    e.g. of dim `channels // compress`.

    Args:
        channels (int): input/output channels for residual branch.
        compress (float, optional): amount of channel compression inside the branch. (default: 4)
        depth (int, optional): number of layers in the residual branch. Each layer has its own
            projection, and potentially LSTM and attention.(default: 2)
        init (float, optional): initial scale for LayerNorm. (default: 1e-4)
        norm_type (bool, optional): Norm type, either ``group_norm `` or ``none`` (Default: ``group_norm``)
        attn (bool, optional): use LocalAttention. (Default: ``False``)
        heads (int, optional): number of heads for the LocalAttention.  (default: 4)
        ndecay (int, optional): number of decay controls in the LocalAttention. (default: 4)
        lstm (bool, optional): use LSTM. (Default: ``False``)
        kernel_size (int, optional): kernel size for the (dilated) convolutions. (default: 3)
    r0   rE   rq   r1   FrR   )
rt   r†   rw   r‡   r9   r…   ÚheadsÚndecayr„   r4   c              
      s<  t ƒ  ¡  |
d dkrtdƒ‚|| _|| _t|ƒ| _|dk}dd„ }|dkrTdd„ }t|| ƒ}tj	}t 
g ¡| _t| jƒD ]º}|rŽtd|ƒnd}||
d  }tj|||
||d	�||ƒ|ƒ t |d| d¡|d| ƒt d¡t||ƒg}|�r| d
t|||d�¡ |	�r | d
t|ddd�¡ tj|Ž }| j |¡ q|d S )NrE   r   z(Kernel size should not be divisible by 2c                 S   s   t  ¡ S r   r=   r?   r   r   r   rA   ©  rB   z!_DConv.__init__.<locals>.<lambda>r1   c                 S   s   t  d| ¡S )Nr   rC   r?   r   r   r   rA   «  rB   r   )ÚdilationÚpaddingrR   )rÅ   rÆ   T©Úlayersri   )r   r   rV   rt   r†   Úabsrw   r(   r   ZGELUrŠ   rÊ   r�   ÚpowrF   ZGLUÚ_LayerScaler”   Ú_LocalStateÚ_BLSTMZ
Sequentialr’   )r   rt   r†   rw   r‡   r9   r…   rÅ   rÆ   r„   r4   ZdilaterN   ÚhiddenZactr@   rÇ   rÈ   ZmodsÚlayerr   r   r   r   ’  s<    


ù	
z_DConv.__init__c                 C   s   | j D ]}|||ƒ }q|S )zÁDConv forward call

        Args:
            x (torch.Tensor): input tensor for convolution

        Returns:
            Tensor
                Output after being run through layers.
        )rÊ   )r   r!   rÑ   r   r   r   r#   Å  s    

z_DConv.forward)	r0   rE   rq   r1   Fr0   r0   FrR   )r$   r%   r&   r'   r(   r)   rc   r*   r   r#   r-   r   r   r   r   rM   }  s.            õõ3rM   c                       s>   e Zd ZdZd
eedœ‡ fdd„Zejejdœdd	„Z	‡  Z
S )rÏ   ae  
    BiLSTM with same hidden units as input dim.
    If `max_steps` is not None, input will be splitting in overlapping
    chunks and the LSTM applied separately on each chunk.
    Args:
        dim (int): dimensions at LSTM layer.
        layers (int, optional): number of LSTM layers. (default: 1)
        skip (bool, optional): (default: ``False``)
    r   FrÉ   c                    s@   t ƒ  ¡  d| _tjd|||d�| _t d| |¡| _|| _d S )NéÈ   T)ÚbidirectionalZ
num_layersZhidden_sizeZ
input_sizerE   )	r   r   Ú	max_stepsr   ZLSTMr„   ZLinearÚlinearri   )r   r   rÊ   ri   r   r   r   r   ß  s
    
z_BLSTM.__init__r    c              	   C   s”  |j \}}}|}d}d}d}d}	| jdk	rv|| jkrv| j}|d }t|||ƒ}
|
j d }	d}|
 dddd¡ d||¡}| ddd¡}|  |¡d }|  |¡}| ddd¡}|�r€g }| |d||¡}
|d }t|	ƒD ]Š}|dk�r| |
dd…|dd…d| …f ¡ qÔ||	d k�r:| |
dd…|dd…|d…f ¡ qÔ| |
dd…|dd…|| …f ¡ qÔt	 
|d¡}|d	d|…f }|}| j�r�|| }|S )
a  BLSTM forward call

        Args:
            x (torch.Tensor): input tensor for BLSTM shape is `(batch_size, dim, time_steps)`

        Returns:
            Tensor
                Output after being run through bidirectional LSTM. Shape is `(batch_size, dim, time_steps)`
        Fr   NrE   Tr   rR   rQ   .)rS   rÔ   Ú_unfoldrX   rY   r„   rÕ   r�   r’   r   Úcatri   )r   r!   r[   r\   r^   r`   ZframedÚwidthr5   ZnframesÚframesr"   ÚlimitÚkr   r   r   r#   æ  sB    



&$&z_BLSTM.forward)r   F)r$   r%   r&   r'   r(   r*   r   r   r,   r#   r-   r   r   r   r   rÏ   Ô  s   
rÏ   c                       s@   e Zd ZdZd	eeedœ‡ fdd„Zejejdœdd„Z‡  Z	S )
rÎ   a   Local state allows to have attention based only on data (no positional embedding),
    but while setting a constraint on the time window (e.g. decaying penalty term).
    Also a failed experiments with trying to provide some frequency based attention.
    r0   )rt   rÅ   rÆ   c                    sÊ   t t| ƒ ¡  || dkr"tdƒ‚|| _|| _t ||d¡| _t ||d¡| _	t ||d¡| _
t ||| d¡| _|r®| jj jd9  _| jjdkrœtdƒ‚d| jjjdd…< t ||d  |d¡| _dS )z¬
        Args:
            channels (int): Size of Conv1d layers.
            heads (int, optional):  (default: 4)
            ndecay (int, optional): (default: 4)
        r   z$Channels must be divisible by heads.r   g{®Gáz„?Nzbias must not be None.rµ   )r   rÎ   r   rV   rÅ   rÆ   r   rF   ÚcontentÚqueryÚkeyÚquery_decayr   r   ÚbiasÚproj)r   rt   rÅ   rÆ   r   r   r   r     s    z_LocalState.__init__r    c                 C   s|  |j \}}}| j}tj||j|jd�}|dd…df |ddd…f  }|  |¡ ||d|¡}|  |¡ ||d|¡}	t 	d|	|¡}
|
t
 |	j d ¡ }
| j�rtjd| jd |j|jd�}|  |¡ ||d|¡}t |¡d }| ddd¡ | ¡  t
 | j¡ }|
t 	d||¡7 }
|
 tj||
jtjd�d¡ tj|
dd	�}|  |¡ ||d|¡}t 	d
||¡}| |d|¡}||  |¡ S )zÏLocalState forward call

        Args:
            x (torch.Tensor): input tensor for LocalState

        Returns:
            Tensor
                Output after being run through LocalState layer.
        )r¶   ÚdtypeNrQ   zbhct,bhcs->bhtsrE   r   zfts,bhfs->bhtsiœÿÿÿr   zbhts,bhct->bhcs)rS   rÅ   r   r   r¶   râ   rÝ   rT   rÞ   Zeinsumr    r   rÆ   rß   ZsigmoidrË   Zmasked_fill_Zeyer*   ZsoftmaxrÜ   rY   rá   )r   r!   r[   r\   r^   rÅ   ZindexesÚdeltaZqueriesÚkeysÚdotsZdecaysZdecay_qZdecay_kernelÚweightsrÜ   Úresultr   r   r   r#   6  s(    
 $z_LocalState.forward)r0   r0   )
r$   r%   r&   r'   r(   r   r   r,   r#   r-   r   r   r   r   rÎ     s   rÎ   c                       s>   e Zd ZdZd	eedœ‡ fdd„Zejejdœdd„Z	‡  Z
S )
rÍ   z£Layer scale from [Touvron et al 2021] (https://arxiv.org/pdf/2103.17239.pdf).
    This rescales diagonally residual outputs close to 0 initially, then learnt.
    r   )rt   r‡   c                    s4   t ƒ  ¡  t tj|dd�¡| _|| jjdd…< dS )z‹
        Args:
            channels (int): Size of  rescaling
            init (float, optional): Scale to default to (default: 0)
        T)Zrequires_gradN)r   r   r   Ú	Parameterr   Úzerosr   r   )r   rt   r‡   r   r   r   r   a  s    
z_LayerScale.__init__r    c                 C   s   | j dd…df | S )z½LayerScale forward call

        Args:
            x (torch.Tensor): input tensor for LayerScale

        Returns:
            Tensor
                Output after rescaling tensor.
        N)r   )r   r!   r   r   r   r#   k  s    
z_LayerScale.forward)r   )r$   r%   r&   r'   r(   r)   r   r   r,   r#   r-   r   r   r   r   rÍ   \  s   
rÍ   )Úar4   r5   r   c                    s¶   t ˆ jdd… ƒ}tˆ jd ƒ}t || ¡}|d | | }tjˆ d|| gd�‰ ‡ fdd„tˆ  ¡ ƒD ƒ}|d dkr‚t	dƒ‚|dd… |dg }| 
|¡ | 
|¡ ˆ  ||¡S )	zûGiven input of size [*OT, T], output Tensor of size [*OT, F, K]
    with K the kernel size, by extracting frames with the given stride.
    This will pad the input so that `F = ceil(T / K)`.
    see https://github.com/pytorch/pytorch/issues/60466
    NrQ   r   r   )r³   r<   c                    s   g | ]}ˆ   |¡‘qS r   )r5   )Ú.0r   ©rê   r   r   Ú
<listcomp>ƒ  s     z_unfold.<locals>.<listcomp>zData should be contiguous.)ÚlistrS   r(   r    r¡   rU   r<   r�   r   rV   r’   Z
as_strided)rê   r4   r5   rS   rj   Zn_framesZ
tgt_lengthÚstridesr   rì   r   rÖ   x  s    

rÖ   c                 C   sp   |   ¡ D ]b}t|tjtjtjtjfƒr|j ¡  	¡ }|d d }|j j
|  _
|jdk	r|j j
|  _
qdS )zI
    Rescales initial weight scale for all models within the module.
    gš™™™™™¹?g      à?N)ÚmodulesÚ
isinstancer   rF   rf   rG   rg   r   r¹   Údetachr   rà   )ÚmoduleÚsubr¹   r   r   r   r   r–   Œ  s    
r–   é   )r!   Ún_fftr‰   r<   r   c           
      C   s€   t | jd d… ƒ}t| jd ƒ}|  d|¡} tj| |d|  |t |¡ | ¡|ddddd�	}|j\}}}	| ||	g¡ | 	|¡S )NrQ   r   Trž   )ÚwindowÚ
win_lengthÚ
normalizedÚcenterZreturn_complexZpad_mode)
rî   rS   r(   rY   r   ZstftÚhann_windowÚtoÚextendrT   )
r!   rö   r‰   r<   Úotherrj   ra   rÄ   r—   Úframer   r   r   r£   ™  s"    
÷r£   )ra   r‰   rj   r<   r   c              
   C   sš   t | jd d… ƒ}t| jd ƒ}t| jd ƒ}d| d }|  d||¡} |d|  }tj| ||t |¡ | j¡|d|dd�}	|	j\}
}| 	|¡ |	 |¡S )Nrµ   rQ   rE   r   T)r÷   rø   rù   rj   rú   )
rî   rS   r(   rT   r   Zistftrû   rü   Úrealr’   )ra   r‰   rj   r<   rþ   r—   rÙ   rö   rø   r!   rÄ   r   r   r   r¦   ­  s&    ø


r¦   )rr   r   c                 C   s   t | ddd�S )zÚBuilds low nfft (1024) version of :class:`HDemucs`, suitable for sample rates around 8 kHz.

    Args:
        sources (List[str]): See :py:func:`HDemucs`.

    Returns:
        HDemucs:
            HDemucs model.
    i   r¯   ©rr   rv   rw   ©rk   ©rr   r   r   r   Úhdemucs_lowÄ  s    r  c                 C   s   t | ddd�S )aÉ  Builds medium nfft (2048) version of :class:`HDemucs`, suitable for sample rates of 16-32 kHz.

    .. note::

        Medium HDemucs has not been tested against the original Hybrid Demucs as this nfft and depth configuration is
        not compatible with the original implementation in https://github.com/facebookresearch/demucs

    Args:
        sources (List[str]): See :py:func:`HDemucs`.

    Returns:
        HDemucs:
            HDemucs model.
    rˆ   rn   r  r  r  r   r   r   Úhdemucs_mediumÒ  s    r  c                 C   s   t | ddd�S )zßBuilds medium nfft (4096) version of :class:`HDemucs`, suitable for sample rates of 44.1-48 kHz.

    Args:
        sources (List[str]): See :py:func:`HDemucs`.

    Returns:
        HDemucs:
            HDemucs model.
    rm   rn   r  r  r  r   r   r   Úhdemucs_highå  s    r  )rõ   r   r   )r   r   r   )r    ÚtypingÚtpr   r   r   r   r   r   Ztorch.nnr   rU   ÚModuler   r.   rd   rk   rM   rÏ   rÎ   rÍ   r,   r(   rÖ   r–   r£   r¦   rc   r  r  r  r   r   r   r   Ú<module>   s,   &nv  RWCE