o
    i#                     @   s   d dl Z d dlmZ d dlm  mZ e e  jZ	G dd dej
ZG dd dej
ZG dd dej
ZG dd	 d	ej
Zd
d ZdddZG dd dej
ZG dd dej
ZdS )    Nc                       s(   e Zd Z	d fdd	Zdd Z  ZS )	TemporalConvNetgLNFreluc                    s   t    || _|
| _t|}tj||ddd}g }t|D ]6}g }t|D ]%}d| }|	r4|d | n|d | d }|t|||d||||	dg7 }q&|tj	| g7 }qtj	| }tj||| ddd}t	||||| _
dS )a%  Basic Module of tasnet.

        Args:
            N: Number of filters in autoencoder
            B: Number of channels in bottleneck 1 * 1-conv block
            H: Number of channels in convolutional blocks
            P: Kernel size in convolutional blocks
            X: Number of convolutional blocks in each repeat
            R: Number of repeats
            C: Number of speakers
            norm_type: BN, gLN, cLN
            causal: causal or non-causal
            mask_nonlinear: use which non-linear function to generate mask
           Fbias   )stridepaddingdilation	norm_typecausalN)super__init__Cmask_nonlinearChannelwiseLayerNormnnConv1drangeTemporalBlock
Sequentialnetwork)selfNBHPXRr   r   r   r   
layer_normbottleneck_conv1x1repeatsrblocksxr   r
   temporal_conv_netmask_conv1x1	__class__ J/home/ubuntu/.local/lib/python3.10/site-packages/espnet2/enh/layers/tcn.pyr      s:   
 

zTemporalConvNet.__init__c                 C   s   |  \}}}| |}||| j||}| jdkr#tj|dd}|S | jdkr/t|}|S | jdkr;t|}|S | jdkrGt	|}|S t
d)zKeep this API same with TasNet.

        Args:
            mixture_w: [M, N, K], M is batch size

        Returns:
            est_mask: [M, C, N, K]
        softmaxr   )dimr   sigmoidtanhz$Unsupported mask non-linear function)sizer   viewr   r   Fr,   r   r.   r/   
ValueError)r   	mixture_wMr   Kscoreest_maskr*   r*   r+   forwardI   s    	

	





zTemporalConvNet.forward)r   Fr   __name__
__module____qualname__r   r9   __classcell__r*   r*   r(   r+   r      s    6r   c                       *   e Zd Z		d fdd	Zdd Z  ZS )r   r   Fc	              	      sZ   t    tj||ddd}	t }
t||}t||||||||}t|	|
||| _d S )Nr   Fr   )	r   r   r   r   PReLUchoose_normDepthwiseSeparableConvr   net)r   in_channelsout_channelskernel_sizer	   r
   r   r   r   conv1x1prelunormdsconvr(   r*   r+   r   c   s   

zTemporalBlock.__init__c                 C   s   |}|  |}|| S )zaForward.

        Args:
            x: [M, B, K]

        Returns:
            [M, B, K]
        rC   )r   r%   residualoutr*   r*   r+   r9      s   	
zTemporalBlock.forwardr   Fr:   r*   r*   r(   r+   r   b   s
    	r   c                       r?   )rB   r   Fc	              
      s   t    tj|||||||dd}	|rt|}
t }t||}tj||ddd}|r8t|	|
|||| _d S t|	|||| _d S )NF)r	   r
   r   groupsr   r   r   )	r   r   r   r   Chomp1dr@   rA   r   rC   )r   rD   rE   rF   r	   r
   r   r   r   depthwise_convchomprH   rI   pointwise_convr(   r*   r+   r      s&   


zDepthwiseSeparableConv.__init__c                 C   s
   |  |S )ziForward.

        Args:
            x: [M, H, K]

        Returns:
            result: [M, B, K]
        rK   r   r%   r*   r*   r+   r9      s   
	zDepthwiseSeparableConv.forwardrN   r:   r*   r*   r(   r+   rB      s
    	$rB   c                       s(   e Zd ZdZ fddZdd Z  ZS )rP   z5To ensure the output length is the same as the input.c                    s   t    || _d S )N)r   r   
chomp_size)r   rU   r(   r*   r+   r      s   

zChomp1d.__init__c                 C   s"   |ddddd| j  f  S )zdForward.

        Args:
            x: [M, H, Kpad]

        Returns:
            [M, H, K]
        N)rU   
contiguousrT   r*   r*   r+   r9      s   "	zChomp1d.forward)r;   r<   r=   __doc__r   r9   r>   r*   r*   r(   r+   rP      s    rP   c                 C   s   | dvrt dd S )N)r,   r   zUnsupported nonlinear type)r3   )nolinear_typer*   r*   r+   check_nonlinear   s   rY   BDTc                 C   sZ   | dkr
t ||dS | dkrt||dS | dkrt|S | dkr)tjd|ddS td	)
zzThe input of normalization will be (M, C, K), where M is batch size.

    C is channel size and K is sequence length.
    r   )shapecLNBNGNr   g:0yE>)epszUnsupported normalization type)GlobalLayerNormr   r   BatchNorm1d	GroupNormr3   )r   channel_sizer[   r*   r*   r+   rA      s   
rA   c                       2   e Zd ZdZd	 fdd	Zdd Zdd Z  ZS )
r   z'Channel-wise Layer Normalization (cLN).rZ   c                    T   t    ttd|d| _ttd|d| _|   |dv s%J || _	d S Nr   )rZ   BTD
r   r   r   	ParametertorchTensorgammabetareset_parametersr[   r   rc   r[   r(   r*   r+   r         

zChannelwiseLayerNorm.__init__c                 C      | j jd | jj  d S Nr   rl   datafill_rm   zero_r   r*   r*   r+   rn         z%ChannelwiseLayerNorm.reset_parametersc                 C   s   |  dksJ | jdkr|dd }tj|ddd}tj|dddd}| j||  t|t	 d	 | j
 }| jdkrE|dd }|S )
zForward.

        Args:
            y: [M, N, K], M is batch size, N is channel size, K is length

        Returns:
            cLN_y: [M, N, K]
           rg   r   r   Tr-   keepdimF)r-   r{   unbiased      ?)r-   r[   	transposerV   rj   meanvarrl   powEPSrm   )r   yr   r   cLN_yr*   r*   r+   r9      s   

$
zChannelwiseLayerNorm.forwardrZ   r;   r<   r=   rW   r   rn   r9   r>   r*   r*   r(   r+   r      
    r   c                       rd   )
r`   z!Global Layer Normalization (gLN).rZ   c                    re   rf   rh   ro   r(   r*   r+   r     rp   zGlobalLayerNorm.__init__c                 C   rq   rr   rs   rw   r*   r*   r+   rn      rx   z GlobalLayerNorm.reset_parametersc                 C   s   | j dkr|dd }|jddd}t|| djddd}| j||  t|t d | j }| j dkr@|dd }|S )zForward.

        Args:
            y: [M, N, K], M is batch size, N is channel size, K is length

        Returns:
            gLN_y: [M, N, K]
        rg   r   r   )r   r   Trz   r}   )	r[   r~   rV   r   rj   r   rl   r   rm   )r   r   r   r   gLN_yr*   r*   r+   r9   $  s   
	$
zGlobalLayerNorm.forwardr   r   r*   r*   r(   r+   r`     r   r`   r   )rj   torch.nnr   torch.nn.functional
functionalr2   finfoget_default_dtyper_   r   Moduler   r   rB   rP   rY   rA   r   r`   r*   r*   r*   r+   <module>   s   
P/1
(