o zi@sddlZddlmZddlmZddlmZddlZddl Z ddl m Z ddl m Z ddl mZdd lmZdd lmZdd lmZd d lmZe jZ GdddZGdddeZGdddeZGdddeZGdddeZGdddeZGdddeZGdddeZGdddeZ Gd d!d!eZ!Gd"d#d#eZ"Gd$d%d%eZ#Gd&d'd'eZ$Gd(d)d)eZ%Gd*d+d+eZ&Gd,d-d-eZ'Gd.d/d/eZ(Gd0d1d1eZ)Gd2d3d3eZ*Gd4d5d5eZ+Gd6d7d7eZ,Gd8d9d9eZ-Gd:d;d;eZ.Gdd?d?eZ0Gd@dAdAeZ1GdBdCdCeZ2GdDdEdEeZ3GdFdGdGeZ4GdHdIdIe2Z5GdJdKdKe1Z6GdLdMdMe Z7dS)NN)contextmanager) signature)List)flatten) unflatten) RandomState)ml) AudioSignal)util) AudioLoaderc@seZdZdZgddfdededefddZd efd d Z d d Z dde de fddZ ed edejfddZde fddZddZ  dde de fddZ  ddede fddZdS) BaseTransforma This is the base class for all transforms that are implemented in this library. Transforms have two main operations: ``transform`` and ``instantiate``. ``instantiate`` sets the parameters randomly from distribution tuples for each parameter. For example, for the ``BackgroundNoise`` transform, the signal-to-noise ratio (``snr``) is chosen randomly by instantiate. By default, it chosen uniformly between 10.0 and 30.0 (the tuple is set to ``("uniform", 10.0, 30.0)``). ``transform`` applies the transform using the instantiated parameters. A simple example is as follows: >>> seed = 0 >>> signal = ... >>> transform = transforms.NoiseFloor(db = ("uniform", -50.0, -30.0)) >>> kwargs = transform.instantiate() >>> output = transform(signal.clone(), **kwargs) By breaking apart the instantiation of parameters from the actual audio processing of the transform, we can make things more reproducible, while also applying the transform on batches of data efficiently on GPU, rather than on individual audio samples. .. note:: We call ``signal.clone()`` for the input to the ``transform`` function because signals are modified in-place! If you don't clone the signal, you will lose the original data. Parameters ---------- keys : list, optional Keys that the transform looks for when calling ``self.transform``, by default []. In general this is set automatically, and you won't need to manipulate this argument. name : str, optional Name of this transform, used to identify it in the dictionary produced by ``self.instantiate``, by default None prob : float, optional Probability of applying this transform, by default 1.0 Examples -------- >>> seed = 0 >>> >>> audio_path = "tests/audio/spk/f10_script4_produced.wav" >>> signal = AudioSignal(audio_path, offset=10, duration=2) >>> transform = tfm.Compose( >>> [ >>> tfm.RoomImpulseResponse(sources=["tests/audio/irs.csv"]), >>> tfm.BackgroundNoise(sources=["tests/audio/noises.csv"]), >>> ], >>> ) >>> >>> kwargs = transform.instantiate(seed, signal) >>> output = transform(signal, **kwargs) N?keysnameprobcs^tt|jj}ddgfdd|D}||dg|_||_|dur*|jj}||_dS)Nsignalkwargscsg|]}|vr|qSr).0k ignore_keysrN/home/ubuntu/.local/lib/python3.10/site-packages/audiotools/data/transforms.py Xsz*BaseTransform.__init__..mask) listr _transform parametersrr __class____name__r)selfrrrtfm_keysrrr__init__Rs zBaseTransform.__init__batchcCs4||j}|jD]}||vsJ|dq|S)Nz not in batch)rr)r"r% sub_batchrrrr_prepareds  zBaseTransform._preparecCs|SNrr"rrrrrlzBaseTransform._transformstatercCsiSr(rr"r+rrrr _instantiateor*zBaseTransform._instantiatercs"fddt|D}t|S)abApplies a mask to the batch. Parameters ---------- batch : dict Batch whose values will be masked in the ``transform`` pass. mask : torch.Tensor Mask to apply to batch. Returns ------- dict A dictionary that contains values only where ``mask = True``. csi|] \}}||qSrrrrvrrr sz,BaseTransform.apply_mask..)ritemsr)r%r masked_batchrr0r apply_maskrszBaseTransform.apply_maskcKsX||}|d}t|r*|||}dd|D}|j||fi|||<|S)atApply the transform to the audio signal, with given keyword arguments. Parameters ---------- signal : AudioSignal Signal that will be modified by the transforms in-place. kwargs: dict Keyword arguments to the specific transforms ``self._transform`` function. Returns ------- AudioSignal Transformed AudioSignal. Examples -------- >>> for seed in range(10): >>> kwargs = transform.instantiate(seed, signal) >>> output = transform(signal.clone(), **kwargs) rcSsi|] \}}|dkr||qSr0rr.rrrr1sz+BaseTransform.transform..)r'torchanyr4r2r)r"rr tfm_kwargsrrrr transforms   zBaseTransform.transformcOs|j|i|Sr(r8)r"argsrrrr__call__zBaseTransform.__call__c Cst|}dtt|jjv}i}|rd|i}|j|fi|}t|D]}||}t|t t j t fr<|||<q(t |||<q(||jk}t ||d<|j|i}|S)aeInstantiates parameters for the transform. Parameters ---------- state : RandomState, optional _description_, by default None signal : AudioSignal, optional _description_, by default None Returns ------- dict Dictionary containing instantiated arguments for every keyword argument to ``self._transform``. Examples -------- >>> for seed in range(10): >>> kwargs = transform.instantiate(seed, signal) >>> output = transform(signal.clone(), **kwargs) rr)r random_statesetrr-rrr isinstancer r5Tensordictttrandrr) r"r+r needs_signalrparamsrr/rrrr instantiates    zBaseTransform.instantiatestatescCs.g}|D] }||||qt|}|S)aInstantiates arguments for every item in a batch, given a list of states. Each state in the list corresponds to one item in the batch. Parameters ---------- states : list, optional List of states, by default None signal : AudioSignal, optional AudioSignal to pass to the ``self.instantiate`` section if it is needed for this transform, by default None Returns ------- dict Collated dictionary of arguments. Examples -------- >>> batch_size = 4 >>> signal = AudioSignal(audio_path, offset=10, duration=2) >>> signal_batch = AudioSignal.batch([signal.clone() for _ in range(batch_size)]) >>> >>> states = [seed + idx for idx in list(range(batch_size))] >>> kwargs = transform.batch_instantiate(states, signal_batch) >>> batch_output = transform(signal_batch, **kwargs) )appendrFr collate)r"rGrrr+rrrbatch_instantiates ! zBaseTransform.batch_instantiater()NN)r! __module__ __qualname____doc__rstrfloatr$rAr'rrr r- staticmethodr5r@r4r8r;rFrJrrrrrs0<# ;rc@seZdZdZdS)Identityz0This transform just returns the original signal.N)r!rKrLrMrrrrrQ srQcs eZdZdZfddZZS)SpectralTransforma.Spectral transforms require STFT data to exist, since manipulations of the STFT require the spectrogram. This just calls ``stft`` before the transform is called, and calls ``istft`` after the transform is called so that the audio data is written to after the spectral manipulation. c s(|tj|fi|||Sr()stftsuperr8istftr"rrr rrr8szSpectralTransform.transform)r!rKrLrMr8 __classcell__rrrWrrRsrRcs|eZdZdZddddededeffdd Zed efd d Z d dZ dde de fddZ ddZddZddZZS)ComposeaCompose applies transforms in sequence, one after the other. The transforms are passed in as positional arguments or as a list like so: >>> transform = tfm.Compose( >>> [ >>> tfm.RoomImpulseResponse(sources=["tests/audio/irs.csv"]), >>> tfm.BackgroundNoise(sources=["tests/audio/noises.csv"]), >>> ], >>> ) This will convolve the signal with a room impulse response, and then add background noise to the signal. Instantiate instantiates all the parameters for every transform in the transform list so the interface for using the Compose transform is the same as everything else: >>> kwargs = transform.instantiate() >>> output = transform(signal.clone(), **kwargs) Under the hood, the transform maps each transform to a unique name under the hood of the form ``{position}.{name}``, where ``position`` is the index of the transform in the list. ``Compose`` can nest within other ``Compose`` transforms, like so: >>> preprocess = transforms.Compose( >>> tfm.GlobalVolumeNorm(), >>> tfm.CrossTalk(), >>> name="preprocess", >>> ) >>> augment = transforms.Compose( >>> tfm.RoomImpulseResponse(), >>> tfm.BackgroundNoise(), >>> name="augment", >>> ) >>> postprocess = transforms.Compose( >>> tfm.VolumeChange(), >>> tfm.RescaleAudio(), >>> tfm.ShiftPhase(), >>> name="postprocess", >>> ) >>> transform = transforms.Compose(preprocess, augment, postprocess), This defines 3 composed transforms, and then composes them in sequence with one another. Parameters ---------- *transforms : list List of transforms to apply name : str, optional Name of this transform, used to identify it in the dictionary produced by ``self.instantiate``, by default None prob : float, optional Probability of applying this transform, by default 1.0 Nrrr transformsrrcsjt|dtr |d}t|D] \}}|d|j|_qdd|D}tj|||d||_||_dS)Nr.cSsg|]}|jqSrr)rtfmrrrrasz$Compose.__init__..)rrr)r?r enumeraterrTr$r[transforms_to_apply)r"rrr[ir^rrWrrr$Zs zCompose.__init__namescgs|j}||_dV||_dS)abThis can be used to skip transforms entirely when applying the sequence of transforms to a signal. For example, take the following transforms with the names ``preprocess, augment, postprocess``. >>> preprocess = transforms.Compose( >>> tfm.GlobalVolumeNorm(), >>> tfm.CrossTalk(), >>> name="preprocess", >>> ) >>> augment = transforms.Compose( >>> tfm.RoomImpulseResponse(), >>> tfm.BackgroundNoise(), >>> name="augment", >>> ) >>> postprocess = transforms.Compose( >>> tfm.VolumeChange(), >>> tfm.RescaleAudio(), >>> tfm.ShiftPhase(), >>> name="postprocess", >>> ) >>> transform = transforms.Compose(preprocess, augment, postprocess) If we wanted to apply all 3 to a signal, we do: >>> kwargs = transform.instantiate() >>> output = transform(signal.clone(), **kwargs) But if we only wanted to apply the ``preprocess`` and ``postprocess`` transforms to the signal, we do: >>> with transform_fn.filter("preprocess", "postprocess"): >>> output = transform(signal.clone(), **kwargs) Parameters ---------- *names : list List of transforms, identified by name, to apply to signal. N)r`)r"rbold_transformsrrrfiltergs ( zCompose.filterc s8|jD]tfdd|jDr|fi|}q|S)Ncsg|]}|jvqSrr])rxr9rrrz&Compose._transform..)r[r6r`rVrr9rrs zCompose._transformr+rcCs(i}|jD] }||j||dq|S)N)r)r[updaterF)r"r+rrr8rrrr-s zCompose._instantiatecCs |j|Sr(r[)r"idxrrr __getitem__ zCompose.__getitem__cCs t|jSr()lenr[)r"rrr__len__rkzCompose.__len__ccs|jD]}|VqdSr(rh)r"r8rrr__iter__s zCompose.__iter__r()r!rKrLrMrrNrOr$rrdrrr r-rjrmrnrXrrrWrrY!s"8 ,rYc sTeZdZdZdddddedededeffd d Zdd ed e ffd d Z Z S)ChooseaChoose logic is the same as :py:func:`audiotools.data.transforms.Compose`, but instead of applying all the transforms in sequence, it applies just a single transform, which is chosen for each item in the batch. Parameters ---------- *transforms : list List of transforms to apply weights : list Probability of choosing any specific transform. name : str, optional Name of this transform, used to identify it in the dictionary produced by ``self.instantiate``, by default None prob : float, optional Probability of applying this transform, by default 1.0 Examples -------- >>> transforms.Choose(tfm.LowPass(), tfm.HighPass()) Nr)weightsrrr[rprrcsLtj|||d|durt|jfddtD}t||_dS)NrZcsg|]}dqS)r rr__lenrrrsz#Choose.__init__..)rTr$rlr[rangenparrayrp)r"rprrr[rWrsrr$s  zChoose.__init__r+rc st||}ttt|j}|j||jd}g}t|jD]$\}}||j d}| r9t ||k||j d<| ||j dq||d<|S)N)prone_hot) rTr-rrurlr[choicerpr_ritemrBrH) r"r+rrtfm_idxryratrrWrrr-szChoose._instantiater() r!rKrLrMrrNrOr$rr r-rXrrrWrros rocs6eZdZdZ   d dededeffdd ZZS) RepeatzRepeatedly applies a given transform ``n_repeat`` times." Parameters ---------- transform : BaseTransform Transform to repeat. n_repeat : int, optional Number of times to repeat transform, by default 1 r Nrn_repeatrrcs2fddt|D}tj|||d||_dS)Ncsg|]}tqSr)copyrqr9rrrrfz#Repeat.__init__..rZ)rurTr$r)r"r8rrrr[rWr9rr$s zRepeat.__init__)r Nr) r!rKrLrMintrNrOr$rXrrrWrr~s r~c s<eZdZdZ    d dedededeffd d ZZ S) RepeatUpToaZRepeatedly applies a given transform up to ``max_repeat`` times." Parameters ---------- transform : BaseTransform Transform to repeat. max_repeat : int, optional Max number of times to repeat transform, by default 1 weights : list Probability of choosing any specific number up to ``max_repeat``. Nr max_repeatrprrcsDg}td|D] }|t||dqtj||||d||_dS)Nr )r)rrrp)rurHr~rTr$r)r"r8rrprrr[nrWrrr$s  zRepeatUpTo.__init__)rNNr) r!rKrLrMrrrNrOr$rXrrrWrrsrcLeZdZdZ   ddededeffdd Zd efd d Z d dZ Z S)ClippingDistortiona.Adds clipping distortion to signal. Corresponds to :py:func:`audiotools.core.effects.EffectMixin.clip_distortion`. Parameters ---------- perc : tuple, optional Clipping percentile. Values are between 0.0 to 1.0. Typical values are 0.1 or below, by default ("uniform", 0.0, 0.1) name : str, optional Name of this transform, used to identify it in the dictionary produced by ``self.instantiate``, by default None prob : float, optional Probability of applying this transform, by default 1.0 uniform皙?Nrpercrrctj||d||_dSNrZ)rTr$r)r"rrrrWrrr$# zClippingDistortion.__init__r+cCdt|j|iS)Nr)r sample_from_distrr"r+rrrr--zClippingDistortion._instantiatecC ||Sr()clip_distortion)r"rrrrrr0rkzClippingDistortion._transform)rNr r!rKrLrMtuplerNrOr$rr-rrXrrrWrr rc sReZdZdZ    ddededed effd d Zd e fd dZ ddZ Z S) EqualizeraaApplies an equalization curve to the audio signal. Corresponds to :py:func:`audiotools.core.effects.EffectMixin.equalizer`. Parameters ---------- eq_amount : tuple, optional The maximum dB cut to apply to the audio in any band, by default ("const", 1.0 dB) n_bands : int, optional Number of bands in EQ, by default 6 name : str, optional Name of this transform, used to identify it in the dictionary produced by ``self.instantiate``, by default None prob : float, optional Probability of applying this transform, by default 1.0 constrNr eq_amountn_bandsrrc tj||d||_||_dSr)rTr$rr)r"rrrrrWrrr$F zEqualizer.__init__r+cCs(t|j|}| ||j}d|iS)Neq)r rrrCr)r"r+rrrrrr-RszEqualizer._instantiatecCrr() equalizer)r"rrrrrrWrkzEqualizer._transform)rrNr r!rKrLrMrrrNrOr$rr-rrXrrrWrr4s" rcTeZdZdZdgdfddfdededeffd d Zd efd d Z ddZ Z S) Quantizationa.Applies quantization to the input waveform. Corresponds to :py:func:`audiotools.core.effects.EffectMixin.quantization`. Parameters ---------- channels : tuple, optional Number of evenly spaced quantization channels to quantize to, by default ("choice", [8, 32, 128, 256, 1024]) name : str, optional Name of this transform, used to identify it in the dictionary produced by ``self.instantiate``, by default None prob : float, optional Probability of applying this transform, by default 1.0 rz iNrchannelsrrcrrrTr$rr"rrrrWrrr$krzQuantization.__init__r+cCrNrr rrrrrrr-urzQuantization._instantiatecCrr() quantizationr"rrrrrrxrkzQuantization._transformrrrrWrr[  rcr)MuLawQuantizationa;Applies mu-law quantization to the input waveform. Corresponds to :py:func:`audiotools.core.effects.EffectMixin.mulaw_quantization`. Parameters ---------- channels : tuple, optional Number of mu-law spaced quantization channels to quantize to, by default ("choice", [8, 32, 128, 256, 1024]) name : str, optional Name of this transform, used to identify it in the dictionary produced by ``self.instantiate``, by default None prob : float, optional Probability of applying this transform, by default 1.0 rzrNrrrrcrrrrrWrrr$rzMuLawQuantization.__init__r+cCrrrrrrrr-rzMuLawQuantization._instantiatecCrr()mulaw_quantizationrrrrrrkzMuLawQuantization._transformrrrrWrr|rrcPeZdZdZ   ddededeffdd Zd ed e fd d Z ddZ Z S) NoiseFlooraAdds a noise floor of Gaussian noise to the signal at a specified dB. Parameters ---------- db : tuple, optional Level of noise to add to signal, by default ("const", -50.0) name : str, optional Name of this transform, used to identify it in the dictionary produced by ``self.instantiate``, by default None prob : float, optional Probability of applying this transform, by default 1.0 rgINrdbrrcrrrTr$rr"rrrrWrrr$rzNoiseFloor.__init__r+rcCs<t|j|}||j|j}t||j}||d|iS)N nz_signal) r rrrandn num_channels signal_lengthr sample_rate normalize)r"r+rr audio_datarrrrr-s   zNoiseFloor._instantiatecCs||Sr(r)r"rrrrrrszNoiseFloor._transform)rNr r!rKrLrMrrNrOr$rr r-rrXrrrWrrs rcsveZdZdZ        ddedeed eed ed ed ed edeffdd Z de de fddZ ddZ ZS)BackgroundNoiseaCAdds background noise from audio specified by a set of CSV files. A valid CSV file looks like, and is typically generated by :py:func:`audiotools.data.preprocess.create_csv`: .. csv-table:: :header: path room_tone/m6_script2_clean.wav room_tone/m6_script2_cleanraw.wav room_tone/m6_script2_ipad_balcony1.wav room_tone/m6_script2_ipad_bedroom1.wav room_tone/m6_script2_ipad_confroom1.wav room_tone/m6_script2_ipad_confroom2.wav room_tone/m6_script2_ipad_livingroom1.wav room_tone/m6_script2_ipad_office1.wav .. note:: All paths are relative to an environment variable called ``PATH_TO_DATA``, so that CSV files are portable across machines where data may be located in different places. This transform calls :py:func:`audiotools.core.effects.EffectMixin.mix` and :py:func:`audiotools.core.effects.EffectMixin.equalizer` under the hood. Parameters ---------- snr : tuple, optional Signal-to-noise ratio, by default ("uniform", 10.0, 30.0) sources : List[str], optional Sources containing folders, or CSVs with paths to audio files, by default None weights : List[float], optional Weights to sample audio files from each source, by default None eq_amount : tuple, optional Amount of equalization to apply, by default ("const", 1.0) n_bands : int, optional Number of bands in equalizer, by default 3 name : str, optional Name of this transform, used to identify it in the dictionary produced by ``self.instantiate``, by default None prob : float, optional Probability of applying this transform, by default 1.0 loudness_cutoff : float, optional Loudness cutoff when loading from audio files, by default None r$@>@Nrrsnrsourcesrprrrrloudness_cutoffc s8tj||d||_||_||_t|||_||_dSr)rTr$rrrr loaderr) r"rrrprrrrrrWrrr$s    zBackgroundNoise.__init__r+rcCsZt|j|}| ||j}t|j|}|j||j|j|j |j dd}|||dS)Ndurationrrr)r bg_signalr) r rrrCrrrrsignal_durationrr)r"r+rrrrrrrrr-s zBackgroundNoise._instantiatecCs||||Sr()mixclone)r"rrrrrrrrszBackgroundNoise._transform)rNNrrNrN)r!rKrLrMrrrNrOrr$rr r-rrXrrrWrrs:1 rc sjeZdZdZ      ddedeedeed ed ed ef fd d Zde de fddZ ddZ Z S) CrossTalkaAdds crosstalk between speakers, whose audio is drawn from a CSV file that was produced via :py:func:`audiotools.data.preprocess.create_csv`. This transform calls :py:func:`audiotools.core.effects.EffectMixin.mix` under the hood. Parameters ---------- snr : tuple, optional How loud cross-talk speaker is relative to original signal in dB, by default ("uniform", 0.0, 10.0) sources : List[str], optional Sources containing folders, or CSVs with paths to audio files, by default None weights : List[float], optional Weights to sample audio files from each source, by default None name : str, optional Name of this transform, used to identify it in the dictionary produced by ``self.instantiate``, by default None prob : float, optional Probability of applying this transform, by default 1.0 loudness_cutoff : float, optional Loudness cutoff when loading from audio files, by default -40 rrrNrrrrprrrcs,tj||d||_t|||_||_dSr)rTr$rr rr)r"rrrprrrrWrrr$5s   zCrossTalk.__init__r+rcCs8t|j|}|j||j|j|j|jdd}||dS)Nrr)crosstalk_signalr)r rrrrrrr)r"r+rrrrrrr-Ds zCrossTalk._instantiatecCs&|}|||}|||Sr()loudnessrrr)r"rrrrrrrrrPs zCrossTalk._transform)rNNNrr)r!rKrLrMrrrNrOr$rr r-rrXrrrWrrs. rcseZdZdZ          dd ed eed eed ed ededede dedeffdd Z dde de fddZ ddZZS)RoomImpulseResponseaConvolves signal with a room impulse response, at a specified direct-to-reverberant ratio, with equalization applied. Room impulse response data is drawn from a CSV file that was produced via :py:func:`audiotools.data.preprocess.create_csv`. This transform calls :py:func:`audiotools.core.effects.EffectMixin.apply_ir` under the hood. Parameters ---------- drr : tuple, optional _description_, by default ("uniform", 0.0, 30.0) sources : List[str], optional Sources containing folders, or CSVs with paths to audio files, by default None weights : List[float], optional Weights to sample audio files from each source, by default None eq_amount : tuple, optional Amount of equalization to apply, by default ("const", 1.0) n_bands : int, optional Number of bands in equalizer, by default 6 name : str, optional Name of this transform, used to identify it in the dictionary produced by ``self.instantiate``, by default None prob : float, optional Probability of applying this transform, by default 1.0 use_original_phase : bool, optional Whether or not to use the original phase, by default False offset : float, optional Offset from each impulse response file to use, by default 0.0 duration : float, optional Duration of each impulse response, by default 1.0 rrrNrrrFrdrrrrprrrruse_original_phaseoffsetrc sDtj||d||_||_||_||_t|||_| |_| |_ dSr) rTr$rrrrr rrr) r"rrrprrrrrrrrWrrr$|s   zRoomImpulseResponse.__init__r+rcCsht|j|}| ||j}t|j|}|j||j|j|j d|j dd}| |j|||dS)N)rrrrr)r ir_signalr) r rrrCrrrrrrr zero_pad_to)r"r+rrrrrrrrr-s  z RoomImpulseResponse._instantiatecCs|j||||jdS)N)r)apply_irrr)r"rrrrrrrrszRoomImpulseResponse._transform) rNNrrNrFrrr()r!rKrLrMrrrNrOrboolr$rr r-rrXrrrWrrYsF$   rcr) VolumeChangeaChanges the volume of the input signal. Uses :py:func:`audiotools.core.effects.EffectMixin.volume_change`. Parameters ---------- db : tuple, optional Change in volume in decibels, by default ("uniform", -12.0, 0.0) name : str, optional Name of this transform, used to identify it in the dictionary produced by ``self.instantiate``, by default None prob : float, optional Probability of applying this transform, by default 1.0 rg(rNrrrrcrrrrrWrrr$ zVolumeChange.__init__r+cCrNrr rrrrrrr-rzVolumeChange._instantiatecCrr( volume_changer"rrrrrrrkzVolumeChange._transform)rNrrrrrWrrs rcr) VolumeNormaNormalizes the volume of the excerpt to a specified decibel. Uses :py:func:`audiotools.core.effects.EffectMixin.normalize`. Parameters ---------- db : tuple, optional dB to normalize signal to, by default ("const", -24) name : str, optional Name of this transform, used to identify it in the dictionary produced by ``self.instantiate``, by default None prob : float, optional Probability of applying this transform, by default 1.0 riNrrrrcrrrrrWrrr$rzVolumeNorm.__init__r+cCrrrrrrrr-rzVolumeNorm._instantiatecCrr()rrrrrrrkzVolumeNorm._transformrNrrrrrWrrrrcr)GlobalVolumeNormaSimilar to :py:func:`audiotools.data.transforms.VolumeNorm`, this transform also normalizes the volume of a signal, but it uses the volume of the entire audio file the loaded excerpt comes from, rather than the volume of just the excerpt. The volume of the entire audio file is expected in ``signal.metadata["loudness"]``. If loading audio from a CSV generated by :py:func:`audiotools.data.preprocess.create_csv` with ``loudness = True``, like the following: .. csv-table:: :header: path,loudness daps/produced/f1_script1_produced.wav,-16.299999237060547 daps/produced/f1_script2_produced.wav,-16.600000381469727 daps/produced/f1_script3_produced.wav,-17.299999237060547 daps/produced/f1_script4_produced.wav,-16.100000381469727 daps/produced/f1_script5_produced.wav,-16.700000762939453 daps/produced/f3_script1_produced.wav,-16.5 The ``AudioLoader`` will automatically load the loudness column into the metadata of the signal. Uses :py:func:`audiotools.core.effects.EffectMixin.volume_change`. Parameters ---------- db : tuple, optional dB to normalize signal to, by default ("const", -24) name : str, optional Name of this transform, used to identify it in the dictionary produced by ``self.instantiate``, by default None prob : float, optional Probability of applying this transform, by default 1.0 rNrrrrcrrrrrWrrr$rzGlobalVolumeNorm.__init__r+rcCs`d|jvr d}d|iSt|jdtdkrd}d|iSt|j|}|t|jd}d|iS)Nrrz-infr)metadatarOr rr)r"r+r db_changerrrrr-s zGlobalVolumeNorm._instantiatecCrr(rrrrrr&rkzGlobalVolumeNorm._transformrrrrrWrrs$  rcs4eZdZdZd dedeffdd Zdd ZZS) SilenceaBZeros out the signal with some probability. Parameters ---------- name : str, optional Name of this transform, used to identify it in the dictionary produced by ``self.instantiate``, by default None prob : float, optional Probability of applying this transform, by default 0.1 Nrrrcstj||ddSrrTr$r"rrrWrrr$6szSilence.__init__cCs*|j}tt|j|j|jd}||_|S)N)r stft_params) _loudnessr r5 zeros_likerrr)r"rrrrrr9s zSilence._transform)Nr) r!rKrLrMrNrOr$rrXrrrWrr*s rc ZeZdZdZdgdfdddfdeded ed effd d Zd e fddZ ddZ Z S)LowPassajApplies a LowPass filter. Uses :py:func:`audiotools.core.dsp.DSPMixin.low_pass`. Parameters ---------- cutoff : tuple, optional Cutoff frequency distribution, by default ``("choice", [4000, 8000, 16000])`` zeros : int, optional Number of zero-crossings in filter, argument to ``julius.LowPassFilters``, by default 51 name : str, optional Name of this transform, used to identify it in the dictionary produced by ``self.instantiate``, by default None prob : float, optional Probability of applying this transform, by default 1.0 rz)ii@i>3Nr cutoffzerosrrcrrrTr$rrr"rrrrrWrrr$[rzLowPass.__init__r+cCrNrr rrrrrrr-grzLowPass._instantiatecC|j||jdSN)r)low_passrr"rrrrrrjr<zLowPass._transformrrrrWrrG"  rc r)HighPassarApplies a HighPass filter. Uses :py:func:`audiotools.core.dsp.DSPMixin.high_pass`. Parameters ---------- cutoff : tuple, optional Cutoff frequency distribution, by default ``("choice", [50, 100, 250, 500, 1000])`` zeros : int, optional Number of zero-crossings in filter, argument to ``julius.LowPassFilters``, by default 51 name : str, optional Name of this transform, used to identify it in the dictionary produced by ``self.instantiate``, by default None prob : float, optional Probability of applying this transform, by default 1.0 rz)2diirNr rrrrcrrrrrWrrr$rzHighPass.__init__r+cCrrrrrrrr-rzHighPass._instantiatecCrr) high_passrrrrrrr<zHighPass._transformrrrrWrrnrrcs8eZdZdZd dededeffdd Zd d ZZS) RescaleAudioa\Rescales the audio so it is in between ``-val`` and ``val`` only if the original audio exceeds those bounds. Useful if transforms have caused the audio to clip. Uses :py:func:`audiotools.core.effects.EffectMixin.ensure_max_of_audio`. Parameters ---------- val : float, optional Max absolute value of signal, by default 1.0 name : str, optional Name of this transform, used to identify it in the dictionary produced by ``self.instantiate``, by default None prob : float, optional Probability of applying this transform, by default 1.0 rNr valrrcrr)rTr$r)r"rrrrWrrr$s zRescaleAudio.__init__cCs ||jSr()ensure_max_of_audiorr)rrrr zRescaleAudio._transform)rNr ) r!rKrLrMrOrNr$rrXrrrWrrsrcsXeZdZdZdej ejfddfdededeffdd Z d e fd d Z d dZ Z S) ShiftPhaseaShifts the phase of the audio. Uses :py:func:`audiotools.core.dsp.DSPMixin.shift)phase`. Parameters ---------- shift : tuple, optional How much to shift phase by, by default ("uniform", -np.pi, np.pi) name : str, optional Name of this transform, used to identify it in the dictionary produced by ``self.instantiate``, by default None prob : float, optional Probability of applying this transform, by default 1.0 rNr shiftrrcrr)rTr$r )r"r rrrWrrr$rzShiftPhase.__init__r+cCr)Nr )r rr rrrrr-rzShiftPhase._instantiatecCrr( shift_phase)r"rr rrrrrkzShiftPhase._transform)r!rKrLrMrvpirrNrOr$rr-rrXrrrWrr s r cs,eZdZdZddedeffdd ZZS) InvertPhaseauInverts the phase of the audio. Uses :py:func:`audiotools.core.dsp.DSPMixin.shift_phase`. Parameters ---------- name : str, optional Name of this transform, used to identify it in the dictionary produced by ``self.instantiate``, by default None prob : float, optional Probability of applying this transform, by default 1.0 Nr rrcstjdtjf||ddS)Nr)r rr)rTr$rvrrrWrrr$szInvertPhase.__init__)Nr )r!rKrLrMrNrOr$rXrrrWrrs rcsZeZdZdZddejfddfdededeffd d Z dd e d e fd dZ ddZ ZS) CorruptPhaseaCorrupts the phase of the audio. Uses :py:func:`audiotools.core.dsp.DSPMixin.corrupt_phase`. Parameters ---------- scale : tuple, optional How much to corrupt phase by, by default ("uniform", 0, np.pi) name : str, optional Name of this transform, used to identify it in the dictionary produced by ``self.instantiate``, by default None prob : float, optional Probability of applying this transform, by default 1.0 rrNr scalerrcrr)rTr$r)r"rrrrWrrr$s zCorruptPhase.__init__r+rcCs6t|j|}|j||jjddd}d|diS)Nr )rsize corruptionfloat32)r rrnormalphaseshapeastype)r"r+rrrrrrr-szCorruptPhase._instantiatecCs |j|dS)N)r r )r"rrrrrrr zCorruptPhase._transformr()r!rKrLrMrvrrrNrOr$rr r-rrXrrrWrrsrc `eZdZdZ    ddededed effd d Zd ed e fddZ dedefddZ Z S) FrequencyMaskarMasks a band of frequencies at a center frequency from the audio. Uses :py:func:`audiotools.core.dsp.DSPMixin.mask_frequencies`. Parameters ---------- f_center : tuple, optional Center frequency between 0.0 and 1.0 (Nyquist), by default ("uniform", 0.0, 1.0) f_width : tuple, optional Width of zero'd out band, by default ("const", 0.1) name : str, optional Name of this transform, used to identify it in the dictionary produced by ``self.instantiate``, by default None prob : float, optional Probability of applying this transform, by default 1.0 rrrrrNr f_centerf_widthrrcrr)rTr$rrr"rrrrrWrrr$ zFrequencyMask.__init__r+rc Csft|j|}t|j|}t||dd}t||dd}|jd|}|jd|}||dS)Nrrrfmin_hzfmax_hz)r rrrmaxminr) r"r+rrrfminfmaxr#r$rrrr-s zFrequencyMask._instantiater#r$cC|j||dS)Nr")mask_frequencies)r"rr#r$rrrr+zFrequencyMask._transformrrNr rrrrWrrs"  rc r)TimeMaskaoMasks out contiguous time-steps from signal. Uses :py:func:`audiotools.core.dsp.DSPMixin.mask_timesteps`. Parameters ---------- t_center : tuple, optional Center time in terms of 0.0 and 1.0 (duration of signal), by default ("uniform", 0.0, 1.0) t_width : tuple, optional Width of dropped out portion, by default ("const", 0.025) name : str, optional Name of this transform, used to identify it in the dictionary produced by ``self.instantiate``, by default None prob : float, optional Probability of applying this transform, by default 1.0 rrg?Nr t_centert_widthrrcrr)rTr$r/r0r"r/r0rrrWrrr$Br!zTimeMask.__init__r+rc Cs^t|j|}t|j|}t||dd}t||dd}|j|}|j|}||dS)Nrrrtmin_stmax_s)r rr/r0r%r&r) r"r+rr/r0tmintmaxr3r4rrrr-Ms   zTimeMask._instantiater3r4cCr))Nr2)mask_timesteps)r"rr3r4rrrrXr+zTimeMask._transformrr.Nr rrrrWrr-/s"  r-csXeZdZdZ   ddededeffdd Zdd ed e fd d Z defddZ Z S)MaskLowMagnitudesaMasks low magnitude regions out of signal. Uses :py:func:`audiotools.core.dsp.DSPMixin.mask_low_magnitudes`. Parameters ---------- db_cutoff : tuple, optional Decibel value for which things below it will be masked away, by default ("uniform", -10, 10) name : str, optional Name of this transform, used to identify it in the dictionary produced by ``self.instantiate``, by default None prob : float, optional Probability of applying this transform, by default 1.0 ri Nr db_cutoffrrcrr)rTr$r<)r"r<rrrWrrr$mrzMaskLowMagnitudes.__init__r+rcCr)Nr<)r rr<r,rrrr-vrzMaskLowMagnitudes._instantiatecCrr()mask_low_magnitudes)r"rr<rrrryrkzMaskLowMagnitudes._transform)r:Nr r(rrrrWrr9\s r9c s`eZdZdZddgdfddfdeded ed effd d Zdd ede fddZ ddZ Z S) SmoothinganConvolves the signal with a smoothing window. Uses :py:func:`audiotools.core.effects.EffectMixin.convolve`. Parameters ---------- window_type : tuple, optional Type of window to use, by default ("const", "average") window_length : tuple, optional Length of smoothing window, by default ("choice", [8, 16, 32, 64, 128, 256, 512]) name : str, optional Name of this transform, used to identify it in the dictionary produced by ``self.instantiate``, by default None prob : float, optional Probability of applying this transform, by default 1.0 )raveragerz)rr@rriNr window_type window_lengthrrcrr)rTr$rBrC)r"rBrCrrrWrrr$r!zSmoothing.__init__r+rcCs<t|j|}t|j|}|j||dd}dt||jiS)Ncpu)rBrCdevicewindow)r rrBrC get_windowr r)r"r+rrBrCrFrrrr-s zSmoothing._instantiatecCs^|jjdddj}d||dk<||}|jjdddj}d||dk<|||}|S)NT)dimkeepdimrr)rabsr%valuesconvolve)r"rrFsscaleoutoscalerrrrs    zSmoothing._transformr(rrrrWrr>}s"  r>c NeZdZdZ    ddededed effd d Zd ed efddZZ S) TimeNoiseaiSimilar to :py:func:`audiotools.data.transforms.TimeMask`, but replaces with noise instead of zeros. Parameters ---------- t_center : tuple, optional Center time in terms of 0.0 and 1.0 (duration of signal), by default ("uniform", 0.0, 1.0) t_width : tuple, optional Width of dropped out portion, by default ("const", 0.025) name : str, optional Name of this transform, used to identify it in the dictionary produced by ``self.instantiate``, by default None prob : float, optional Probability of applying this transform, by default 1.0 rr.Nr r/r0rrctj||||ddS)N)r/r0rrrr1rWrrr$zTimeNoise.__init__r3r4c Csl|j||dd}|j|j}}t|t|}}|dk|dk}||||<||||<||_||_|S)Nr)r3r4r)r7 magnituderr5 randn_like) r"rr3r4magrmag_rphase_rrrrrrs  zTimeNoise._transformr8 r!rKrLrMrrNrOr$rrXrrrWrrRs  rRc rQ)FrequencyNoiseaVSimilar to :py:func:`audiotools.data.transforms.FrequencyMask`, but replaces with noise instead of zeros. Parameters ---------- f_center : tuple, optional Center frequency between 0.0 and 1.0 (Nyquist), by default ("uniform", 0.0, 1.0) f_width : tuple, optional Width of zero'd out band, by default ("const", 0.1) name : str, optional Name of this transform, used to identify it in the dictionary produced by ``self.instantiate``, by default None prob : float, optional Probability of applying this transform, by default 1.0 rrNr rrrrcrS)N)rrrrrr rWrrr$rTzFrequencyNoise.__init__r#r$c Csj|j||d}|j|j}}t|t|}}|dk|dk}||||<||||<||_||_|S)Nr"r)r*rUrr5rV) r"rr#r$rWrrXrYrrrrrs  zFrequencyNoise._transformr,rZrrrWrr[s  r[csneZdZdZ        dd ed ed ed ededededeffdd ZddZ de ffdd Z Z S)SpectralDenoisingaApplies denoising algorithm detailed in :py:func:`audiotools.ml.layers.spectral_gate.SpectralGate`, using a randomly generated noise signal for denoising. Parameters ---------- eq_amount : tuple, optional Amount of eq to apply to noise signal, by default ("const", 1.0) denoise_amount : tuple, optional Amount to denoise by, by default ("uniform", 0.8, 1.0) nz_volume : float, optional Volume of noise to denoise with, by default -40 n_bands : int, optional Number of bands in equalizer, by default 6 n_freq : int, optional Number of frequency bins to smooth by, by default 3 n_time : int, optional Number of time bins to smooth by, by default 5 name : str, optional Name of this transform, used to identify it in the dictionary produced by ``self.instantiate``, by default None prob : float, optional Probability of applying this transform, by default 1.0 rrg?rrrrrNr rdenoise_amount nz_volumern_freqn_timerrc s4tj||||d||_||_tj|||_dS)N)rrrr)rTr$r_r^r layers SpectralGate spectral_gate) r"rr^r_rr`rarrrWrrr$s zSpectralDenoising.__init__cCs4||j|}|j|j|_||||}|Sr()rr_rrdtorE)r"rnzrr^rrrr.szSpectralDenoising._transformr+cs6t|}t|j||d<t|dd|d<|S)Nr^i"ViDrf)rTr-r rr^r r)r"r+rrWrrr-4s zSpectralDenoising._instantiate)rr]rrrrNr ) r!rKrLrMrrOrrNr$rrr-rXrrrWrr\s: r\)8r contextlibrinspectrtypingrnumpyrvr5 flatten_dictrr numpy.randomrr corer r datasetsr tensorrBrrQrRrYror~rrrrrrrrrrrrrrrrr rrrr-r9r>rRr[r\rrrrsb          x 3!'!!&X>T !<'' .-!3*)