o 7wi@sdZddlZddlZddlmmZddlZddlm Z ddl m Z ddl m Z mZmZmZmZGdddejjZGdd d ejjZGd d d ejjZGd d d ejjZGdddejjZGdddejjZGdddejjZGdddejjZGdddejjZGdddejjZGdddejjZGdddejjZd&d d!ZGd"d#d#ejjZ Gd$d%d%ejjZ!dS)'aTime-Domain Sequential Data Augmentation Classes This module contains classes designed for augmenting sequential data in the time domain. It is particularly useful for enhancing the robustness of neural models during training. The available data distortions include adding noise, applying reverberation, adjusting playback speed, and more. All classes are implemented as `torch.nn.Module`, enabling end-to-end differentiability and gradient backpropagation. Authors: - Peter Plantinga (2020) - Mirco Ravanelli (2023) N)make_dataloader)ExtendedCSVDataset)compute_amplitude convolve1ddB_to_amplitude notch_filter reverberatec sjeZdZdZdddddddddejiddf fdd Zd d Zd d Zd dZ e ddZ ddZ Z S)AddNoiseaf This class additively combines a noise signal to the input signal. Arguments --------- csv_file : str The name of a csv file containing the location of the noise audio files. If none is provided, white noise will be used. csv_keys : list, None, optional Default: None . One data entry for the noise data should be specified. If None, the csv file is expected to have only one data entry. sorting : str The order to iterate the csv file, from one of the following options: random, original, ascending, and descending. num_workers : int Number of workers in the DataLoader (See PyTorch DataLoader docs). snr_low : int The low end of the mixing ratios, in decibels. snr_high : int The high end of the mixing ratios, in decibels. pad_noise : bool If True, copy noise signals that are shorter than their corresponding clean signals so as to cover the whole clean signal. Otherwise, leave the noise un-padded. start_index : int The index in the noise waveforms to start from. By default, chooses a random index in [0, len(noise) - len(waveforms)]. normalize : bool If True, output noisy signals that exceed [-1,1] will be normalized to [-1,1]. noise_funct: funct object function to use to draw a noisy sample. It is enabled if the csv files containing the noisy sequences are not provided. By default, torch.randn_like is used (to sample white noise). In general, it must be a function that takes in input the original waveform and returns a tensor with the corresponding noise to add (e.g., see pink_noise_like). replacements : dict A set of string replacements to carry out in the csv file. Each time a key is found in the text, it will be replaced with the corresponding value. noise_sample_rate : int The sample rate of the noise audio signals, so noise can be resampled to the clean sample rate if necessary. clean_sample_rate : int The sample rate of the clean audio signals, so noise can be resampled to the clean sample rate if necessary. Example ------- >>> import pytest >>> from speechbrain.dataio.dataio import read_audio >>> signal = read_audio('tests/samples/single-mic/example1.wav') >>> clean = signal.unsqueeze(0) # [batch, time, channels] >>> noisifier = AddNoise('tests/samples/annotation/noise.csv', ... replacements={'noise_folder': 'tests/samples/noise'}) >>> noisy = noisifier(clean, torch.ones(1)) NrandomrF>cs\t||_||_||_||_||_||_||_||_ | |_ | |_ | |_ | |_ | |_dSN)super__init__csv_filecsv_keyssorting num_workerssnr_lowsnr_high pad_noise start_index normalize replacements noise_functnoise_sample_rateclean_sample_rate)selfrrrrrrrrrrrrr __class__\/home/ubuntu/sommelier/.venv/lib/python3.10/site-packages/speechbrain/augment/time_domain.pyrYs  zAddNoise.__init__cCsH|}||jdd}t||dd}tjt|d|jd}||j|j |j }dt |d}t|jdkr?|d}||}|d|9}|j durj| |}|jddkrgtj |g|jddd}|} n |jd} ||| \}} t|| dd} ||| d 9}||7}|jrtjt|dd d \} } || jd d }|S)aY Arguments --------- waveforms : torch.Tensor Shape should be `[batch, time]` or `[batch, time, channels]`. lengths : torch.Tensor Shape should be a single dimension, `[batch]`. Returns ------- Tensor of shape `[batch, time]` or `[batch, time, channels]`. rms)amp_typedeviceNrdim+=Tr(keepdim?min)cloneshape unsqueezertorchrandlenr%rrrrrcat _load_noisermaxabsclamp)r waveformslengthsnoisy_waveformclean_amplitudeSNRnoise_amplitude_factornew_noise_amplitudenoise_waveform noise_length tensor_lengthnoise_amplitudeabs_max_rrr forwardys@       zAddNoise.forwardc Cs|d}t|}t|dsM|j|jkrt|j|j|_|j|_|j durMt |j |j |j dkr4|j nd|j d}t|||j|j dkd|_t|j|_||\}}||j}||j}t|drj||}||jd}|jrt||krt|}|ddd|f}tj||fdd }||7}t||ks}n|d|krd ||df} tjj|| }|j} |jdurd } ||j dd } tj!| d |jd } |dd| | |f}|| j |d"d}||fS)zLoad a batch of noisesr! data_loaderNr original)csvpath output_keysrr) batch_sizershuffle resampler)axisrr-r!)highsizer%)r7)#longsqueezer4hasattrrrResamplerNr%rrrrrrrrHiter noise_data_load_noise_batch_of_sizetor0rr2anyr.r5rRnn functionalpadrr9randintr1) rr; max_lengthrLdataset noise_batch noise_lenmin_lenprependpaddingrmax_choprrr r6sb          zAddNoise._load_noisecCsp|\}}t||kr"|\}}t||||\}}t||ks t||kr4|d|}|d|}||fS)z4Concatenate noise batches, then chop to correct sizeN)_load_noise_batchr4r _concat_batch)rrLrb noise_lens added_noise added_lensrrr rYs      z"AddNoise._load_noise_batch_of_sizecCs|jd}|jd}dt||f}||kr%tjj||}|||}ntjj||}|||}t||f}t||f}||fS)z>Concatenate two noise batches of potentially different lengthsr!r)r0r8r2r\r]r^r5)rbrjrkrlnoise_tensor_lenadded_tensor_lenr^rrr ris   zAddNoise._concat_batchcCsXzt|jd\}}W||fSty+t|j|_t|jd\}}Y||fSw)z:Load a batch of noises, restarting iteration if necessary.r)nextrX at_position StopIterationrWrH)rnoiseslensrrr rh*s zAddNoise._load_noise_batch)__name__ __module__ __qualname____doc__r2 randn_likerrGr6rY staticmethodrirh __classcell__rrrr r s,; AI r cs>eZdZdZdddiddffdd Zdd Zd d ZZS) AddReverbagThis class convolves an audio signal with an impulse response. Arguments --------- csv_file : str The name of a csv file containing the location of the impulse response files. sorting : str The order to iterate the csv file, from one of the following options: random, original, ascending, and descending. num_workers : int Number of workers in the DataLoader (See PyTorch DataLoader docs). rir_scale_factor: float It compresses or dilates the given impulse response. If 0 < scale_factor < 1, the impulse response is compressed (less reverb), while if scale_factor > 1 it is dilated (more reverb). replacements : dict A set of string replacements to carry out in the csv file. Each time a key is found in the text, it will be replaced with the corresponding value. reverb_sample_rate : int The sample rate of the corruption signals (rirs), so that they can be resampled to clean sample rate if necessary. clean_sample_rate : int The sample rate of the clean signals, so that the corruption signals can be resampled to the clean sample rate before convolution. Example ------- >>> import pytest >>> from speechbrain.dataio.dataio import read_audio >>> signal = read_audio('tests/samples/single-mic/example1.wav') >>> clean = signal.unsqueeze(0) # [batch, time, channels] >>> reverb = AddReverb('tests/samples/annotation/RIRs.csv', ... replacements={'rir_folder': 'tests/samples/RIRs'}) >>> reverbed = reverb(clean) r rr,r cs8t||_||_||_||_||_||_||_dSr ) r rrrrrreverb_sample_raterrir_scale_factor)rrrrr}rr|rrrr r^s  zAddReverb.__init__cCs|j|jkrt|j|j|_d}t|jdkr|d}d}||}t|dr-||}|j dkrFt j | dd|j ddd}| dd}t ||d d }|rT|dS|S) Arguments --------- waveforms : torch.Tensor Shape should be `[batch, time]` or `[batch, time, channels]`. Returns ------- Tensor of shape `[batch, time]` or `[batch, time, channels]`. FTrNr!linear) scale_factormode align_cornersavg) rescale_amp)r|rrVrNr4r0r1 _load_rirrUr}F interpolate transposerrT)rr: channel_added rir_waveform rev_waveformrrr rGqs.         zAddReverb.forwardcCst|ds(t|j|jdkr|jnd|jd}t||jdk|jd|_t|j|_ z t |j  d\}}Wnt yMt|j|_ t |j  d\}}Ynwt |jdkrZ|d}||j}||jS) NrHr rI)rJrr)rMrrrr)rUrrrrrrrHrWrir_datarorprqr4r0r1typedtyperZr%)rr:rarlengthrrr rs,       zAddReverb._load_rir)rtrurvrwrrGrrzrrrr r{6s*0r{cs2eZdZdZgddffdd ZddZZS) SpeedPerturbaSlightly speed up or slow down an audio signal. Resample the audio signal at a rate that is similar to the original rate, to achieve a slightly slower or slightly faster signal. This technique is outlined in the paper: "Audio Augmentation for Speech Recognition" Arguments --------- orig_freq : int The frequency of the original signal. speeds : list The speeds that the signal should be changed to, as a percentage of the original signal (i.e. `speeds` is divided by 100 to get a ratio). device : str The device to use for the resampling. Example ------- >>> from speechbrain.dataio.dataio import read_audio >>> signal = read_audio('tests/samples/single-mic/example1.wav') >>> perturbator = SpeedPerturb(orig_freq=16000, speeds=[90]) >>> clean = signal.unsqueeze(0) >>> perturbed = perturbator(clean) >>> clean.shape torch.Size([1, 52173]) >>> perturbed.shape torch.Size([1, 46956]) )Zdncpucsdt||_||_||_d|_g|_|jD]}|j|j|dd}|jtdi|qdS)Nrr orig_freqnew_freqr) r rrspeedsr% samp_index resamplersappendrV)rrrr%speedconfigrrr rs   zSpeedPerturb.__init__cCs:tdt|jd|_|j|j||j}||jS)a Arguments --------- waveform : torch.Tensor Shape should be `[batch, time]` or `[batch, time, channels]`. Returns ------- torch.Tensor of shape `[batch, time]` or `[batch, time, channels]`. rrP)r2r_r4rrrrZr%)rwaveformperturbed_waveformrrr rGs    zSpeedPerturb.forwardrtrurvrwrrGrzrrrr rsrc*eZdZdZdfdd ZddZZS)rVaThis class resamples audio using the :class:`torchaudio resampler ` based on sinc interpolation. Arguments --------- orig_freq : int the sampling frequency of the input signal. new_freq : int the new sampling frequency after this operation is performed. *args additional arguments forwarded to the :class:`torchaudio.transforms.Resample` constructor **kwargs additional keyword arguments forwarded to the :class:`torchaudio.transforms.Resample` constructor Example ------- >>> from speechbrain.dataio.dataio import read_audio >>> signal = read_audio('tests/samples/single-mic/example1.wav') >>> signal = signal.unsqueeze(0) # [batch, time, channels] >>> resampler = Resample(orig_freq=16000, new_freq=8000) >>> resampled = resampler(signal) >>> signal.shape torch.Size([1, 52173]) >>> resampled.shape torch.Size([1, 26087]) r cs4t||_||_tjj|||d||_dS)Nr)r rrr torchaudio transformsrVrN)rrrargskwargsrrr r$s  zResample.__init__cCs|j|jkr|Sd}t|jdkr|d}d}nt|jdkr'|dd}ntd|j|j ||}|r@| d}|S|dd}|S)r~Frr!Tr&zInput must be 2 or 3 dimensions) rrr4r0r1r ValueErrorrNrZr%rT)rr: unsqueezedresampled_waveformrrr rG.s     zResample.forward)r r rrrrr rVs rVcs6eZdZdZ      d fdd Zd d ZZS) DropFreqa%This class drops a random frequency from the signal. The purpose of this class is to teach models to learn to rely on all parts of the signal, not just a few frequency bands. Arguments --------- drop_freq_low : float The low end of frequencies that can be dropped, as a fraction of the sampling rate / 2. drop_freq_high : float The high end of frequencies that can be dropped, as a fraction of the sampling rate / 2. drop_freq_count_low : int The low end of number of frequencies that could be dropped. drop_freq_count_high : int The high end of number of frequencies that could be dropped. drop_freq_width : float The width of the frequency band to drop, as a fraction of the sampling_rate / 2. epsilon : float A small positive value to prevent issues such as filtering 0 Hz, division by zero, or other numerical instabilities. This value sets the absolute minimum for normalized frequencies used in the filter. The default value is 1e-12. Example ------- >>> from speechbrain.dataio.dataio import read_audio >>> dropper = DropFreq() >>> signal = read_audio('tests/samples/single-mic/example1.wav') >>> dropped_signal = dropper(signal.unsqueeze(0)) r)r!r&皙?-q=cs2t||_||_||_||_||_||_dSr )r r drop_freq_lowdrop_freq_highdrop_freq_count_lowdrop_freq_count_highdrop_freq_widthepsilon)rrrrrrrrrr r|s  zDropFreq.__init__c Cs2|}t|jdkr|d}tj|j|jddd}|j|j }t |||j j |j d}d}|d}tj d|d|jd}d|d |d f<|D]} t| ||j|j} t|| |}qJt|jd krw||jd |jd|jdd}t|||}t|jd kr||jd |jd|jd}|dS) r~rrr!rPlowrQrRr-er$rr&)r/r4r0r1r2r_rrrrr3r9rzerosr%rrrZrreshaperT) rr:dropped_waveform drop_count drop_rangedrop_frequency filter_lengthr^ drop_filter frequency notch_kernelrrr rGsF     zDropFreq.forward)r)r!r!r&rrrrrrr rYs$rcs8eZdZdZ       d fd d Zd d ZZS) DropChunkaThis class drops portions of the input signal. Using `DropChunk` as an augmentation strategy helps a models learn to rely on all parts of the signal, since it can't expect a given part to be present. Arguments --------- drop_length_low : int The low end of lengths for which to set the signal to zero, in samples. drop_length_high : int The high end of lengths for which to set the signal to zero, in samples. drop_count_low : int The low end of number of times that the signal can be dropped to zero. drop_count_high : int The high end of number of times that the signal can be dropped to zero. drop_start : int The first index for which dropping will be allowed. drop_end : int The last index for which dropping will be allowed. noise_factor : float The factor relative to average amplitude of an utterance to use for scaling the white noise inserted. 1 keeps the average amplitude the same, while 0 inserts all 0's. Example ------- >>> from speechbrain.dataio.dataio import read_audio >>> dropper = DropChunk(drop_start=100, drop_end=200, noise_factor=0.) >>> signal = read_audio('tests/samples/single-mic/example1.wav') >>> signal = signal.unsqueeze(0) # [batch, time, channels] >>> length = torch.ones(1) >>> dropped_signal = dropper(signal, length) >>> float(dropped_signal[:, 150]) 0.0 rr!r&rNc st||_||_||_||_||_||_||_||kr"t d||kr*t d|durL|dkrN||kr:t d||}t |||_t |||_dSdSdS)N*Low limit must not be more than high limitr) r rdrop_length_lowdrop_length_highdrop_count_lowdrop_count_high drop_startdrop_end noise_factorrr.) rrrrrrrrrrrr rs&  zDropChunk.__init__cCs||d}|d}|}t||d}tj|j|jd|fd}t |D]}||dkr4q+tj|j |j d||fd}|j } | dkrP| ||7} |j } | dur[||} | dkre| ||7} td| |} tj| | d||fd} | |} |jst ||D]} d||| | | | f<qq+d|||j}t ||D] } tj|| |jd}d|||}|||| | | | f<qq+|S)ad Arguments --------- waveforms : torch.Tensor Shape should be `[batch, time]` or `[batch, time, channels]`. lengths : torch.Tensor Shape should be a single dimension, `[batch]`. Returns ------- Tensor of shape `[batch, time]` or `[batch, time, channels]` r!rrNrrr$)rRrSr/rr1r2r_rrrangerrrrr7rr3r%)rr:r;rLrr= drop_timesir start_min start_maxstartendj noise_max noise_vecrrr rGsR     zDropChunk.forward)rrr!r&rNrrrrrr rs+"rcs@eZdZdZ       dfdd Zd d Zd d ZZS) FastDropChunka.This class drops portions of the input signal. The difference with DropChunk is that in this case we pre-compute the dropping masks in the first time the forward function is called. For all the other calls, we only shuffle and apply them. This makes the code faster and more suitable for data augmentation of large batches. It can be used only for fixed-length sequences. Arguments --------- drop_length_low : int The low end of lengths for which to set the signal to zero, in samples. drop_length_high : int The high end of lengths for which to set the signal to zero, in samples. drop_count_low : int The low end of number of times that the signal can be dropped to zero. drop_count_high : int The high end of number of times that the signal can be dropped to zero. drop_start : int The first index for which dropping will be allowed. drop_end : int The last index for which dropping will be allowed. n_masks : int The number of precomputed masks. Example ------- >>> from speechbrain.dataio.dataio import read_audio >>> dropper = FastDropChunk(drop_start=100, drop_end=200) >>> signal = torch.rand(10, 250, 22) >>> dropped_signal = dropper(signal) rrr! rNc st||_||_||_||_||_||_||_d|_ ||kr%t d||kr-t d|durO|dkrQ||kr=t d||}t |||_t |||_dSdSdS)NTrr) r rrrrrrrn_masksfirstrr.) rrrrrrrrrrrr rs(  zFastDropChunk.__init__c Cs4|j|jdkr tdtj|j|jg|jd}tj|j|j d|jf|jd}t |jD]j}||dkr6q-tj|j |j d||f|jd}|j }|dkrS||j7}|j}|dur]|j}|dkrf||j7}td||}tj||d||f|jd}||} t ||D]} d|||| | | f<qq-|S)a Arguments --------- waveforms : torch.Tensor Shape should be `[batch, time]` or `[batch, time, channels]`. `. Returns ------- dropped_masks : torch.Tensor Tensor of size `[n_masks, time]` with the dropped chunks. Dropped regions are assigned to 0. rz,n_mask cannot be smaller than the batch sizer$r!)rrQrRr%Nr)rr0rr2onessig_lenr%r_rrrrrrrr7) rr: dropped_masksrrrrrrrrrrr initialize_maskssP   zFastDropChunk.initialize_maskscCs|}|jr|jd|_|||_d|_t|jjd}|j|ddf|_tjd|jdd}tj |j| dd|_t |jdkrV||jd|jd d }|S||jd|jd}|S) Arguments --------- waveforms : torch.Tensor Shape should be `[batch, time]` or `[batch, time, channels]`. Returns ------- Tensor of shape `[batch, time]` or `[batch, time, channels]` r!FrNrPrshiftsdimsr&r) r/rr0rrrr2randpermr_rollitemr4r1)rr:dropped_waveforms rand_perm rand_shiftsrrr rGs*     zFastDropChunk.forward)rrr!rrNr)rtrurvrwrrrGrzrrrr rhs'"Frcr)DoClipaThis function mimics audio clipping by clamping the input tensor. First, it normalizes the waveforms from -1 to -1. Then, clipping is applied. Finally, the original amplitude is restored. Arguments --------- clip_low : float The low end of amplitudes for which to clip the signal. clip_high : float The high end of amplitudes for which to clip the signal. Example ------- >>> from speechbrain.dataio.dataio import read_audio >>> clipper = DoClip(clip_low=0.01, clip_high=0.01) >>> signal = read_audio('tests/samples/single-mic/example1.wav') >>> clipped_signal = clipper(signal.unsqueeze(0)) ?ct||_||_dSr )r rclip_low clip_high)rrrrrr r4  zDoClip.__init__cCsjtjt|ddd\}}||}|j|j}tjd|jdd||j}|| |}|||}|S)rr!Tr*r$r)r2r7r8rrr3r%r9)rr:rErFclipping_range clip_valueclipped_waveformrrr rG9s   zDoClip.forward)rrrrrrr r rc*eZdZdZdfdd ZddZZS) RandAmpakThis function multiples the signal by a random amplitude. First, the signal is normalized to have amplitude between -1 and 1. Then it is multiplied with a random number. Arguments --------- amp_low : float The minimum amplitude multiplication factor. amp_high : float The maximum amplitude multiplication factor. Example ------- >>> from speechbrain.dataio.dataio import read_audio >>> rand_amp = RandAmp(amp_low=0.25, amp_high=1.75) >>> signal = read_audio('tests/samples/single-mic/example1.wav') >>> output_signal = rand_amp(signal.unsqueeze(0)) r?crr )r ramp_lowamp_high)rrrrrr rmrzRandAmp.__init__cCs|tjt|ddd\}}||}|j|j}tj|jd|jd||j}|d}t |jdkr8|d}||}|S)rr!Tr*rr$r&r) r2r7r8rrr3r0r%r1r4)rr:rErF rand_rangeamprrr rGrs    zRandAmp.forward)rrrrrrr rYrrcr) ChannelDropa8This function drops random channels in the multi-channel input waveform. Arguments --------- drop_rate : float The channel dropout factor Example ------- >>> signal = torch.rand(4, 256, 8) >>> ch_drop = ChannelDrop(drop_rate=0.5) >>> output_signal = ch_drop(signal) 皙?ct||_dSr )r r drop_rate)rrrrr r  zChannelDrop.__init__cCs:tj|jd|jd}||j}||dd}|S)rrr$rr!)r2r3r0r%gerr1)rr:x channel_maskrrr rGs zChannelDrop.forward)rrrrrr rsrcr) ChannelSwapaXThis function randomly swaps N channels. Arguments --------- min_swap : int The minimum number of channels to swap. max_swap : int The maximum number of channels to swap. Example ------- >>> signal = torch.rand(4, 256, 8) >>> ch_swap = ChannelSwap() >>> output_signal = ch_swap(signal) rcsRt||_||_|jdkrtd|jdkrtd|j|jkr'tddS)Nrzmin_swap must be >= 0.zmax_swap must be >= 0.zmax_swap must be >= min_swap)r rmin_swapmax_swapr)rrrrrr rs    zChannelSwap.__init__cCst|jd}t|jd}tj|j|jddd}||jdkr^t|D]4}|dddd||f}|dddd||f|dddd||f<||dddd||f<q'|S|dddd|f}|S)rrr!rPrN)r2rr0r_rrr)rr: rand_perm1 rand_perm2N_swapsr store_channelrrr rGs  0zChannelSwap.forward)rrrrrrr rs rcr) CutCata$This function combines segments (with equal length in time) of the time series contained in the batch. Proposed for EEG signals in https://doi.org/10.1016/j.neunet.2021.05.032. Arguments --------- min_num_segments : int The number of segments to combine. max_num_segments : int The maximum number of segments to combine. Default is 10. Example ------- >>> signal = torch.ones((4, 256, 22)) * torch.arange(4).reshape((4, 1, 1,)) >>> cutcat = CutCat() >>> output_signal = cutcat(signal) rrcs.t||_||_|j|jkrtddS)Nz-max_num_segments must be >= min_num_segments)r rmin_num_segmentsmax_num_segmentsr)rr r rrr rs  zCutCat.__init__cCs|jddkr\tj|ddd}tj|j|jddd}tjd|jd|dtjd}t |jddD]&}|ddkr[||}||d}|dd||d f|dd||d f<q5|S) rrr!rrPr)rrN.) r0r2rr_r r linspacerintr)rr:waveforms_rolled num_segmentsidx_cutrrstoprrr rG s&   zCutCat.forward)rrrrrrr rsrr,2cCs@t|}tjj|dd}||}tj|jd|jd||}tjd|dt|jdd|jd}dt| d| d} | dddf| dddf<tj | dd} |jddr|| ddt|jdddf d} tj | | | gdd} n tj | | gdd} t |jd kr| d} || } tjj | ddj} | S) a5Creates a sequence of pink noise (also known as 1/f). The pink noise is obtained by multiplying the spectrum of a white noise sequence by a factor (1/f^alpha). The alpha factor controls the decrease factor in the frequency domain (alpha=0 adds white noise, alpha>>0 adds low frequency noise). It is randomly sampled between alpha_low and alpha_high. With negative alpha this function generates blue noise. Arguments --------- waveforms : torch.Tensor The original waveform. It is just used to infer the shape. alpha_low : float The minimum value for the alpha spectral smoothing factor. alpha_high : float The maximum value for the alpha spectral smoothing factor. sample_rate : float The sample rate of the original signal. Returns ------- pink_noise : torch.Tensor Pink noise in the shape of the input tensor. Example ------- >>> waveforms = torch.randn(4,257,10) >>> noise = pink_noise_like(waveforms) >>> noise.shape torch.Size([4, 257, 10]) r!r'rr$rNrP)rr&)r2rxfftr3r0r%r r powr1flipr5r4ifftreal)r: alpha_low alpha_high sample_rate white_noisewhite_noise_fftralphaf spectral_maskspectral_mask_up mid_elementpink_noise_fft pink_noiserrr pink_noise_like3s> !  r#cr)DropBitResolutiona6 This class transforms a float32 tensor into a lower resolution one (e.g., int16, int8, float16) and then converts it back to a float32. This process loses information and can be used for data augmentation. Arguments: --------- target_dtype: str One of "int16", "int8", "float16". If "random", the bit resolution is randomly selected among the options listed above. Example: >>> dropper = DropBitResolution() >>> signal = torch.rand(4, 16000) >>> signal_dropped = dropper(signal) r csft||_dtjfdtjfdtjfd|_|jdkr/|j|jvr1tdt |j dSdS)N)int16int8float16r ztarget_dtype must be one of ) r r target_dtyper2r'r(r) bit_depthsrlistkeys)rr*rrr rs   zDropBitResolution.__init__cCs|jdkrtt|j}|j|\}}n|j|j\}}|tjkr:d|dd| }|| |}n| }d}| tj |}|S)aC Arguments: --------- float32_tensor: torch.Tensor Float32 tensor with shape `[batch, time]` or `[batch, time, channels]`. Returns: --------- torch.Tensor Tensor of shape `[batch, time]` or `[batch, time, channels]` (Float32) r rr!) r*r choicer,r+r-r2r)r8r7rZhalffloat32)rfloat32_tensor random_keybitr*rquantized_tensordequantized_tensorrrr rGs  zDropBitResolution.forward)r rrrrr r$sr$cr)SignFlipaFlip the sign of a signal. This module negates all the values in a tensor with a given probability. If the sign is not flipped, the original signal is returned unchanged. This technique is outlined in the paper: "CADDA: Class-wise Automatic Differentiable Data Augmentation for EEG Signals" https://arxiv.org/pdf/2106.13695 Arguments --------- flip_prob : float The probability with which to flip the sign of the signal. Default is 0.5. Example ------- >>> import torch >>> x = torch.tensor([1,2,3,4,5]) >>> flip = SignFlip(flip_prob=1) # 100% chance to flip sign >>> flip(x) tensor([-1, -2, -3, -4, -5]) rcrr )r r flip_prob)rr7rrr rrzSignFlip.__init__cCstd|jkr | S|S)az Arguments --------- waveform : torch.Tensor Input tensor representaing waveform, shape does not matter. Returns ------- torch.Tensor The output tensor with same shape as the input, where the sign of all values in the tensor has been flipped with probability `flip_prob`. r!)r2r3rr7)rrrrr rGszSignFlip.forward)rrrrrr r6sr6)r,r,r)"rwr r2torch.nn.functionalr\r]rrspeechbrain.dataio.dataloaderrspeechbrain.dataio.legacyr(speechbrain.processing.signal_processingrrrrrModuler r{rrVrrrrrrrrr#r$r6rrrr s8     DTv997&= @SD