o %ݫi/L@sdZddlZddlmZGdddejZGdddejZGdddejZGd d d ejZGd d d ejZ Gd ddejZ GdddejZ GdddejZ dS)uvLibrary implementing normalization. Authors * Mirco Ravanelli 2020 * Guillermo Cámbara 2021 * Sarthak Yadav 2022 Ncs:eZdZdZ        d fdd Zd d ZZS) BatchNorm1daJApplies 1d batch normalization to the input tensor. Arguments --------- input_shape : tuple The expected shape of the input. Alternatively, use ``input_size``. input_size : int The expected size of the input. Alternatively, use ``input_shape``. eps : float This value is added to std deviation estimation to improve the numerical stability. momentum : float It is a value used for the running_mean and running_var computation. affine : bool When set to True, the affine parameters are learned. track_running_stats : bool When set to True, this module tracks the running mean and variance, and when set to False, this module does not track such statistics. combine_batch_time : bool When true, it combines batch an time axis. skip_transpose : bool Whether to skip the transposition. Example ------- >>> input = torch.randn(100, 10) >>> norm = BatchNorm1d(input_shape=input.shape) >>> output = norm(input) >>> output.shape torch.Size([100, 10]) Nh㈵>皙?TFc sVt||_||_|dur|r|d}n|dur|d}tj|||||d|_dS)Nepsmomentumaffinetrack_running_stats)super__init__combine_batch_timeskip_transposennrnorm) self input_shape input_sizerr r r rr __class__R/home/ubuntu/.local/lib/python3.10/site-packages/speechbrain/nnet/normalization.pyr /s    zBatchNorm1d.__init__cCs|j}|jr,|jdkr||d|d|d}n||d|d|d|d}n |js5|dd}||}|jrD||}|S|jsM|dd}|S)agReturns the normalized input tensor. Arguments --------- x : torch.Tensor (batch, time, [channels]) input to normalize. 2d or 3d tensors are expected in input 4d tensors can be used when combine_dims=True. Returns ------- x_n : torch.Tensor The normalized outputs. rrr)shaperndimreshaper transposer)rxshape_orx_nrrrforwardKs      zBatchNorm1d.forward)NNrrTTFF__name__ __module__ __qualname____doc__r r" __classcell__rrrrr s#rcs6eZdZdZ      d fdd Zdd ZZS) BatchNorm2daApplies 2d batch normalization to the input tensor. Arguments --------- input_shape : tuple The expected shape of the input. Alternatively, use ``input_size``. input_size : int The expected size of the input. Alternatively, use ``input_shape``. eps : float This value is added to std deviation estimation to improve the numerical stability. momentum : float It is a value used for the running_mean and running_var computation. affine : bool When set to True, the affine parameters are learned. track_running_stats : bool When set to True, this module tracks the running mean and variance, and when set to False, this module does not track such statistics. Example ------- >>> input = torch.randn(100, 10, 5, 20) >>> norm = BatchNorm2d(input_shape=input.shape) >>> output = norm(input) >>> output.shape torch.Size([100, 10, 5, 20]) NrrTcLt|dur|durtd|dur|d}tj|||||d|_dS)N+Expected input_shape or input_size as inputrr)r r ValueErrorrr)r)rrrrr r r rrrr   zBatchNorm2d.__init__cC&|dd}||}|dd}|Sa&Returns the normalized input tensor. Arguments --------- x : torch.Tensor (batch, time, channel1, channel2) input to normalize. 4d tensors are expected. Returns ------- x_n : torch.Tensor The normalized outputs. rrrrrrr!rrrr"  zBatchNorm2d.forward)NNrrTTr#rrrrr)osr)cs2eZdZdZ    d fdd ZddZZS) LayerNormaApplies layer normalization to the input tensor. Arguments --------- input_size : int The expected size of the dimension to be normalized. input_shape : tuple The expected shape of the input. eps : float This value is added to std deviation estimation to improve the numerical stability. elementwise_affine : bool If True, this module has learnable per-element affine parameters initialized to ones (for weights) and zeros (for biases). Example ------- >>> input = torch.randn(100, 101, 128) >>> norm = LayerNorm(input_shape=input.shape) >>> output = norm(input) >>> output.shape torch.Size([100, 101, 128]) NrTcsFt||_||_|dur|dd}tjj||j|jd|_dS)Nr)relementwise_affine)r r rr4torchrr3r)rrrrr4rrrr s   zLayerNorm.__init__cCs ||S)aReturns the normalized input tensor. Arguments --------- x : torch.Tensor (batch, time, channels) input to normalize. 3d or 4d tensors are expected. Returns ------- The normalized outputs. )r)rrrrrr"s zLayerNorm.forward)NNrTr#rrrrr3sr3c6eZdZdZ      d fdd Zd d ZZS) InstanceNorm1da:Applies 1d instance normalization to the input tensor. Arguments --------- input_shape : tuple The expected shape of the input. Alternatively, use ``input_size``. input_size : int The expected size of the input. Alternatively, use ``input_shape``. eps : float This value is added to std deviation estimation to improve the numerical stability. momentum : float It is a value used for the running_mean and running_var computation. track_running_stats : bool When set to True, this module tracks the running mean and variance, and when set to False, this module does not track such statistics. affine : bool A boolean value that when set to True, this module has learnable affine parameters, initialized the same way as done for batch normalization. Default: False. Example ------- >>> input = torch.randn(100, 10, 20) >>> norm = InstanceNorm1d(input_shape=input.shape) >>> output = norm(input) >>> output.shape torch.Size([100, 10, 20]) NrrTFcr*Nr+r)rr r r )r r r,rr7rrrrrr r r rrrr r-zInstanceNorm1d.__init__cCr.)aReturns the normalized input tensor. Arguments --------- x : torch.Tensor (batch, time, channels) input to normalize. 3d tensors are expected. Returns ------- x_n : torch.Tensor The normalized outputs. rrr0r1rrrr"-r2zInstanceNorm1d.forwardNNrrTFr#rrrrr7 r7cr6) InstanceNorm2da@Applies 2d instance normalization to the input tensor. Arguments --------- input_shape : tuple The expected shape of the input. Alternatively, use ``input_size``. input_size : int The expected size of the input. Alternatively, use ``input_shape``. eps : float This value is added to std deviation estimation to improve the numerical stability. momentum : float It is a value used for the running_mean and running_var computation. track_running_stats : bool When set to True, this module tracks the running mean and variance, and when set to False, this module does not track such statistics. affine : bool A boolean value that when set to True, this module has learnable affine parameters, initialized the same way as done for batch normalization. Default: False. Example ------- >>> input = torch.randn(100, 10, 20, 2) >>> norm = InstanceNorm2d(input_shape=input.shape) >>> output = norm(input) >>> output.shape torch.Size([100, 10, 20, 2]) NrrTFcr*r8)r r r,rr<rr9rrrr `r-zInstanceNorm2d.__init__cCr.r/r0r1rrrr"yr2zInstanceNorm2d.forwardr:r#rrrrr<Ar;r<cs4eZdZdZ     d fdd ZddZZS) GroupNormabApplies group normalization to the input tensor. Arguments --------- input_shape : tuple The expected shape of the input. Alternatively, use ``input_size``. input_size : int The expected size of the input. Alternatively, use ``input_shape``. num_groups : int Number of groups to separate the channels into. eps : float This value is added to std deviation estimation to improve the numerical stability. affine : bool A boolean value that when set to True, this module has learnable per-channel affine parameters initialized to ones (for weights) and zeros (for biases). Example ------- >>> input = torch.randn(100, 101, 128) >>> norm = GroupNorm(input_size=128, num_groups=128) >>> output = norm(input) >>> output.shape torch.Size([100, 101, 128]) NrTcslt||_||_|dur|durtd|durtd|dur'|d}tjj|||j|jd|_dS)Nr+zExpected num_groups as inputr)rr ) r r rr r,r5rr=r)rrr num_groupsrr rrrr s  zGroupNorm.__init__cCr.)a"Returns the normalized input tensor. Arguments --------- x : torch.Tensor (batch, time, channels) input to normalize. 3d or 4d tensors are expected. Returns ------- x_n : torch.Tensor The normalized outputs. rrr0r1rrrr"r2zGroupNorm.forward)NNNrTr#rrrrr=sr=c sHeZdZdZ    ddedededed ef fd d Zd d ZZ S)ExponentialMovingAveragea6 Applies learnable exponential moving average, as required by learnable PCEN layer Arguments --------- input_size : int The expected size of the input. coeff_init: float Initial smoothing coefficient value per_channel: bool Controls whether every smoothing coefficients are learned independently for every input channel trainable: bool whether to learn the PCEN parameters or use fixed skip_transpose : bool If False, uses batch x time x channel convention of speechbrain. If True, uses batch x channel x time convention. Example ------- >>> inp_tensor = torch.rand([10, 50, 40]) >>> pcen = ExponentialMovingAverage(40) >>> out_tensor = pcen(inp_tensor) >>> out_tensor.shape torch.Size([10, 50, 40]) {Gz?FTr coeff_init per_channel trainablercsVt||_||_||_||_|jrt|ntd}tj ||j|d|_ dS)Nr requires_grad) r r _coeff_init _per_channelrrCr5onesr Parameter_weights)rrrArBrCrweightsrrrr s   z!ExponentialMovingAverage.__init__cCsd|js |dd}tj|jddd}|dddddf}dd }||||}|js0|dd}|S) zReturns the normalized input tensor. Arguments --------- x : torch.Tensor (batch, time, channels) input to normalize. rrg?)minmaxNrcSsr|ddd}|}g}t|jdD]}|||d||}||dqtj|dd}|ddd}|S)zLoops and accumulates.rrrrL)dim)permuterangerappend unsqueezer5cat) init_staterwaccresultsixrrrscansz.ExponentialMovingAverage.forward..scan)rrr5clamprJ)rrrV initial_staterZoutputrrrr"s   z ExponentialMovingAverage.forward)r@FTF) r$r%r&r'intfloatboolr r"r(rrrrr?s$r?cs\eZdZdZ        dded ed ed ed ed ededeffdd ZddZZS)PCENa This class implements a learnable Per-channel energy normalization (PCEN) layer, supporting both original PCEN as specified in [1] as well as sPCEN as specified in [2] [1] Yuxuan Wang, Pascal Getreuer, Thad Hughes, Richard F. Lyon, Rif A. Saurous, "Trainable Frontend For Robust and Far-Field Keyword Spotting", in Proc of ICASSP 2017 (https://arxiv.org/abs/1607.05666) [2] Neil Zeghidour, Olivier Teboul, F{'e}lix de Chaumont Quitry & Marco Tagliasacchi, "LEAF: A LEARNABLE FRONTEND FOR AUDIO CLASSIFICATION", in Proc of ICLR 2021 (https://arxiv.org/abs/2101.08596) The default argument values correspond with those used by [2]. Arguments --------- input_size : int The expected size of the input. alpha: float specifies alpha coefficient for PCEN smooth_coef: float specified smooth coefficient for PCEN delta: float specifies delta coefficient for PCEN root: float specifies root coefficient for PCEN floor: float specifies floor coefficient for PCEN trainable: bool whether to learn the PCEN parameters or use fixed per_channel_smooth_coef: bool whether to learn independent smooth coefficients for every channel. when True, essentially using sPCEN from [2] skip_transpose : bool If False, uses batch x time x channel convention of speechbrain. If True, uses batch x channel x time convention. Example ------- >>> inp_tensor = torch.rand([10, 50, 40]) >>> pcen = PCEN(40, alpha=0.96) # sPCEN >>> out_tensor = pcen(inp_tensor) >>> out_tensor.shape torch.Size([10, 50, 40]) Q?r@@-q=TFalpha smooth_coefdeltarootfloorrCper_channel_smooth_coefrc st||_||_||_| |_tjt |||d|_ tjt |||d|_ tjt |||d|_ t ||j|jd|d|_dS)NrDT)rArBrrC)r r _smooth_coef_floor_per_channel_smooth_coefrrrIr5rHrergrhr?ema) rrrerfrgrhrirCrjrrrrr Zs*  z PCEN.__init__cCs|js |dd}t|jtjd|j|jd}t|j tjd|j|jd}| |}d|}||j || ddd|j ddd| ddd|j ddd| ddd}|jse|dd}|S)aReturns the normalized input tensor. Arguments --------- x : torch.Tensor (batch, time, channels) input to normalize. Returns ------- output : torch.Tensor The normalized outputs. rrrL)dtypedevice)rrr5rMretensorrorprNrhrnrlviewrg)rrrerh ema_smoother one_over_rootr]rrrr"}s4    z PCEN.forward)rbr@rcrcrdTTF) r$r%r&r'r_r`r r"r(rrrrra-s8/  #ra) r'r5torch.nnrModulerr)r3r7r<r=r?rarrrrs bJ<LLKU