P/jXSVddlZddlZddlmZmZmZmZmZddlZddlm Z ddl m Z ddl m Z ddlmZddlmZmZmZmZmZgZGdd ej0j2ZGd d ej0j2ZGd d ej0j2ZGddej0j2ZGddej0j2ZGddej0j2ZGddej0j2Z Gddej0j2Z!Gddej0j2Z"Gddej0j2Z#Gddej0j2Z$Gddej0j2Z%Gd d!ej0j2Z&Gd"d#ej0j2Z'Gd$d%ej0j2Z(Gd&d'ej0j2Z)Gd(d)e)Z*Gd*d+e)Z+Gd,d-ej0j2Z,Gd.d/ej0j2Z-Gd0d1ej0j2Z.Gd2d3ej0j2Z/Gd4d5ej0j2Z0Gd6d7ej0j2Z1Gd8d9e ej0j2Z2Gd:d;ej0j2Z3Gd<d=ej0j2Z4Gd>d?ej0j2Z5d@e6dAe7dBee6e6ffdCZ8GdDdEej0j2Z9GdFdGej0j2Z:GdHdIej0j2Z;GdJdKej0j2Z<GdLdMej0j2Z=y)NN)CallableOptionalSequenceTupleUnion)Tensor)LazyModuleMixin)UninitializedParameter) functional)_apply_sinc_resample_kernel_check_convolve_mode_fix_waveform_shape_get_sinc_resample_kernel_stretch_waveformceZdZdZgdZddddej ddddd ddf d ed eed eed ede de fdee de e efdeede dede dee ddffd Zde de fdZxZS) SpectrogramaCreate a spectrogram from a audio signal. .. devices:: CPU CUDA .. properties:: Autograd TorchScript Args: n_fft (int, optional): Size of FFT, creates ``n_fft // 2 + 1`` bins. (Default: ``400``) win_length (int or None, optional): Window size. (Default: ``n_fft``) hop_length (int or None, optional): Length of hop between STFT windows. (Default: ``win_length // 2``) pad (int, optional): Two sided padding of signal. (Default: ``0``) window_fn (Callable[..., Tensor], optional): A function to create a window tensor that is applied/multiplied to each frame/window. (Default: ``torch.hann_window``) power (float or None, optional): Exponent for the magnitude spectrogram, (must be > 0) e.g., 1 for magnitude, 2 for power, etc. If None, then the complex spectrum is returned instead. (Default: ``2``) normalized (bool or str, optional): Whether to normalize by magnitude after stft. If input is str, choices are ``"window"`` and ``"frame_length"``, if specific normalization type is desirable. ``True`` maps to ``"window"``. (Default: ``False``) wkwargs (dict or None, optional): Arguments for window function. (Default: ``None``) center (bool, optional): whether to pad :attr:`waveform` on both sides so that the :math:`t`-th frame is centered at time :math:`t \times \text{hop\_length}`. (Default: ``True``) pad_mode (string, optional): controls the padding method used when :attr:`center` is ``True``. (Default: ``"reflect"``) onesided (bool, optional): controls whether to return half of results to avoid redundancy (Default: ``True``) return_complex (bool, optional): Deprecated and not used. Example >>> waveform, sample_rate = torchaudio.load("test.wav", normalize=True) >>> transform = torchaudio.transforms.Spectrogram(n_fft=800) >>> spectrogram = transform(waveform) n_fft win_length hop_lengthpadpower normalizedNr@FTreflectrrrr window_fn.rrwkwargscenterpad_modeonesidedreturn_complexreturnc tt| tjj d||_||n||_||n|jdz|_|||jn||jfi|} |jd| ||_ ||_ ||_ | |_ | |_| |_| t!j"dyy)Nz!torchaudio.transforms.Spectrogramwindowz`return_complex` argument is now deprecated and is not effective.`torchaudio.transforms.Spectrogram(power=None)` always returns a tensor with complex dtype. Please remove the argument in the function call.)superr__init__torch_C_log_api_usage_oncerrrregister_bufferrrrrr r!warningswarn)selfrrrrrrrrrr r!r"r& __class__s d/root/repos/pocs/video-evals/.venv/lib/python3.12/site-packages/torchaudio/transforms/_transforms.pyr(zSpectrogram.__init__?s k4)+ $$%HI )3(>*E(2(>*DOOWXDX/64??+IdooDiahDi Xv. $      % MMR  &waveformc tj||j|j|j|j |j |j|j|j|j|j S)a< Args: waveform (Tensor): Tensor of audio of dimension (..., time). Returns: Tensor: Dimension (..., freq, time), where freq is ``n_fft // 2 + 1`` where ``n_fft`` is the number of Fourier bins, and time is the number of window hops (n_frame). ) F spectrogramrr&rrrrrrr r!r/r3s r1forwardzSpectrogram.forwardds^}}  HH KK JJ OO OO JJ OO KK MM MM  r2)__name__ __module__ __qualname____doc__ __constants__r) hann_windowintrrrfloatrboolstrdictr(r8 __classcell__r0s@r1rrs#HXM$($(+0+<+>> batch, freq, time = 2, 257, 100 >>> length = 25344 >>> spectrogram = torch.randn(batch, freq, time, dtype=torch.cdouble) >>> transform = transforms.InverseSpectrogram(n_fft=512) >>> waveform = transform(spectrogram, length) rrNrFTrrrrrr.rrrr r!r#c 6tt| ||_||n||_||n|jdz|_|||jn||jfi|} |j d| ||_||_||_ | |_ | |_ yNr%r&) r'rGr(rrrr,rrrr r!) r/rrrrrrrrr r!r&r0s r1r(zInverseSpectrogram.__init__s  $02 )3(>*E(2(>*DOOWXDX/64??+IdooDiahDi Xv.$     r2r6lengthc tj|||j|j|j|j |j |j|j|j|j S)a. Args: spectrogram (Tensor): Complex tensor of audio of dimension (..., freq, time). length (int or None, optional): The output length of the waveform. Returns: Tensor: Dimension (..., time), Least squares estimation of the original signal. ) r5inverse_spectrogramrr&rrrrrr r!)r/r6rJs r1r8zInverseSpectrogram.forwards\$$   HH KK JJ OO OO OO KK MM MM  r2N)r9r:r;r<r=r)r>r?rrrrrArBrCr(r8rDrEs@r1rGrG}s@XM$($(+0+<+<',"&!!!SM!SM !  ! CK( !$)$!$!!!! !6 6 8C= F r2rGceZdZdZgdZddddej dddddf d ed ed eed eed e de fde dee de deede ddffd Zde de fdZxZS) GriffinLimaiCompute waveform from a linear scale magnitude spectrogram using the Griffin-Lim transformation. .. devices:: CPU CUDA .. properties:: Autograd TorchScript Implementation ported from *librosa* :cite:`brian_mcfee-proc-scipy-2015`, *A fast Griffin-Lim algorithm* :cite:`6701851` and *Signal estimation from modified short-time Fourier transform* :cite:`1172092`. Args: n_fft (int, optional): Size of FFT, creates ``n_fft // 2 + 1`` bins. (Default: ``400``) n_iter (int, optional): Number of iteration for phase recovery process. (Default: ``32``) win_length (int or None, optional): Window size. (Default: ``n_fft``) hop_length (int or None, optional): Length of hop between STFT windows. (Default: ``win_length // 2``) window_fn (Callable[..., Tensor], optional): A function to create a window tensor that is applied/multiplied to each frame/window. (Default: ``torch.hann_window``) power (float, optional): Exponent for the magnitude spectrogram, (must be > 0) e.g., 1 for magnitude, 2 for power, etc. (Default: ``2``) wkwargs (dict or None, optional): Arguments for window function. (Default: ``None``) momentum (float, optional): The momentum parameter for fast Griffin-Lim. Setting this to 0 recovers the original Griffin-Lim method. Values near 1 can lead to faster convergence, but above 1 may not converge. (Default: ``0.99``) length (int, optional): Array length of the expected output. (Default: ``None``) rand_init (bool, optional): Initializes phase randomly if True and to zero otherwise. (Default: ``True``) Example >>> batch, freq, time = 2, 257, 100 >>> spectrogram = torch.randn(batch, freq, time) >>> transform = transforms.GriffinLim(n_fft=512) >>> waveform = transform(spectrogram) )rn_iterrrrrJmomentum rand_initr NrGz?TrrPrrr.rrrQrJrRr#c tt| d|cxkrdksntdj |||_||_||n||_||n|jdz|_|||jn||jfi|} |jd| | |_ ||_ ||_ | |_ y)Nrz/momentum must be in the range [0, 1). Found: {}r%r&)r'rOr( ValueErrorformatrrPrrr,rJrrQrR) r/rrPrrrrrrQrJrRr&r0s r1r(zGriffinLim.__init__s j$(*X!!NUUV^_` `  (2(>*E(2(>*DOOWXDX/64??+IdooDiahDi Xv.    "r2specgramc tj||j|j|j|j |j |j|j|j|j S)a/ Args: specgram (Tensor): A magnitude-only STFT spectrogram of dimension (..., freq, frames) where freq is ``n_fft // 2 + 1``. Returns: Tensor: waveform of (..., time), where time equals the ``length`` parameter if given. ) r5 griffinlimr&rrrrrPrQrJrRr/rYs r1r8zGriffinLim.forwardsW||  KK JJ OO OO JJ KK MM KK NN  r2)r9r:r;r<r=r)r>r?rrrr@rCrAr(r8rDrEs@r1rOrOs@pM$($(+0+<+<"& $###SM # SM # CK( ##$## ## #:  6 r2rOcPeZdZdZgdZd dedeeddffd Zde de fd Z xZ S) AmplitudeToDBaWTurn a tensor from the power/amplitude scale to the decibel scale. .. devices:: CPU CUDA .. properties:: Autograd TorchScript This output depends on the maximum value in the input tensor, and so may return different values for an audio clip split into snippets vs. a a full clip. Args: stype (str, optional): scale of input tensor (``"power"`` or ``"magnitude"``). The power being the elementwise square of the magnitude. (Default: ``"power"``) top_db (float or None, optional): minimum negative cut-off in decibels. A reasonable number is 80. (Default: ``None``) Example >>> waveform, sample_rate = torchaudio.load("test.wav", normalize=True) >>> transform = transforms.AmplitudeToDB(stype="amplitude", top_db=80) >>> waveform_db = transform(waveform) ) multiplieramin ref_value db_multiplierNstypetop_dbr#ctt| ||_||dkr t d||_|dk(rdnd|_d|_d|_tjt|j|j|_ y)Nrztop_db must be positive valuerg$@4@g|=?) r'r^r(rcrWrdr_r`ramathlog10maxrb)r/rcrdr0s r1r(zAmplitudeToDB.__init__Cst mT+-  &1*<= = "'7"2$ !ZZDIIt~~(FGr2xctj||j|j|j|j S)a*Numerically stable implementation from Librosa. https://librosa.org/doc/latest/generated/librosa.amplitude_to_db.html Args: x (Tensor): Input tensor before being converted to decibel scale. Returns: Tensor: Output tensor in decibel scale. )r5amplitude_to_DBr_r`rbrdr/rks r1r8zAmplitudeToDB.forwardNs2  DOOTYY@R@RTXT_T_``r2)rN) r9r:r;r<r=rBrr@r(rr8rDrEs@r1r^r^+sI*IM Hc HXe_ HPT H a aF ar2r^cxeZdZdZgdZ ddedededeeded eed ed dffd Z d e d e fdZ xZ S)MelScaleafTurn a normal STFT into a mel frequency STFT with triangular filter banks. .. devices:: CPU CUDA .. properties:: Autograd TorchScript Args: n_mels (int, optional): Number of mel filterbanks. (Default: ``128``) sample_rate (int, optional): Sample rate of audio signal. (Default: ``16000``) f_min (float, optional): Minimum frequency. (Default: ``0.``) f_max (float or None, optional): Maximum frequency. (Default: ``sample_rate // 2``) n_stft (int, optional): Number of bins in STFT. See ``n_fft`` in :class:`Spectrogram`. (Default: ``201``) norm (str or None, optional): If ``"slaney"``, divide the triangular mel weights by the width of the mel band (area normalization). (Default: ``None``) mel_scale (str, optional): Scale to use: ``htk`` or ``slaney``. (Default: ``htk``) Example >>> waveform, sample_rate = torchaudio.load("test.wav", normalize=True) >>> spectrogram_transform = transforms.Spectrogram(n_fft=1024) >>> spectrogram = spectrogram_transform(waveform) >>> melscale_transform = transforms.MelScale(sample_rate=sample_rate, n_stft=1024 // 2 + 1) >>> melscale_spectrogram = melscale_transform(spectrogram) See also: :py:func:`torchaudio.functional.melscale_fbanks` - The function used to generate the filter banks. )n_mels sample_ratef_minf_maxNrqrrrsrtn_stftnorm mel_scaler#c tt| ||_||_||n t |dz|_||_||_||_ ||j kDr%tdj||j tj||j|j |j|j|j|j}|jd|y)Nr%Require f_min: {} <= f_max: {}fb)r'rpr(rqrrr@rtrsrvrwrWrXr5melscale_fbanksr,) r/rqrrrsrtrurvrwrzr0s r1r(zMelScale.__init__zs h&( &#/UU;!;K5L   " 4:: =DDUDJJWX X   vtzz4::t{{DL\L\^b^g^gimiwiw x T2&r2rYctj|jdd|jjdd}|S)z Args: specgram (Tensor): A spectrogram STFT of dimension (..., freq, time). Returns: Tensor: Mel frequency spectrogram of size (..., ``n_mels``, time). )r)matmul transposerz)r/rY mel_specgrams r1r8zMelScale.forwards:||H$6$6r2$>HRRSUWYZ r2)>NNhtk r9r:r;r<r=r?r@rrBr(rr8rDrEs@r1rprp\s6@M !%"''' '  '  'sm'' '0  6 r2rpc|eZdZdZgdZ ddededededeed eed ed ed dffd Z de d e fdZ xZ S)InverseMelScaleaEstimate a STFT in normal frequency domain from mel frequency domain. .. devices:: CPU CUDA It minimizes the euclidian norm between the input mel-spectrogram and the product between the estimated spectrogram and the filter banks using `torch.linalg.lstsq`. Args: n_stft (int): Number of bins in STFT. See ``n_fft`` in :class:`Spectrogram`. n_mels (int, optional): Number of mel filterbanks. (Default: ``128``) sample_rate (int, optional): Sample rate of audio signal. (Default: ``16000``) f_min (float, optional): Minimum frequency. (Default: ``0.``) f_max (float or None, optional): Maximum frequency. (Default: ``sample_rate // 2``) norm (str or None, optional): If "slaney", divide the triangular mel weights by the width of the mel band (area normalization). (Default: ``None``) mel_scale (str, optional): Scale to use: ``htk`` or ``slaney``. (Default: ``htk``) driver (str, optional): Name of the LAPACK/MAGMA method to be used for `torch.lstsq`. For CPU inputs the valid values are ``"gels"``, ``"gelsy"``, ``"gelsd"``, ``"gelss"``. For CUDA input, the only valid driver is ``"gels"``, which assumes that A is full-rank. (Default: ``"gels``) Example >>> waveform, sample_rate = torchaudio.load("test.wav", normalize=True) >>> mel_spectrogram_transform = transforms.MelSpectrogram(sample_rate, n_fft=1024) >>> mel_spectrogram = mel_spectrogram_transform(waveform) >>> inverse_melscale_transform = transforms.InverseMelScale(n_stft=1024 // 2 + 1) >>> spectrogram = inverse_melscale_transform(mel_spectrogram) )rurqrrrsrtNrurqrrrsrtrvrwdriverr#c tt| ||_||_|xst |dz|_||_||_||j kDr%tdj||j |dvrtd|dtj||j|j |j|j||} |jd| y)Nr%ry)gelsgelsygelsdgelsszAdriver must be one of ["gels", "gelsy", "gelsd", "gelss"]. Found .rz)r'rr(rqrrr@rtrsrrWrXr5r{r,) r/rurqrrrsrtrvrwrrzr0s r1r(zInverseMelScale.__init__s ot-/ &5eK1$45   4:: =DDUDJJWX X < <`ag`hhijk k   vtzz4::t{{DL\L\^bdm n T2&r2melspecc |j}|jd|d|d}|d|d}}|jj\}}|j|k7r%t dj |j|t jt jj|jjddd||jj}|j|dd||fz}|S)z Args: melspec (Tensor): A Mel frequency spectrogram of dimension (..., ``n_mels``, time) Returns: Tensor: Linear scale spectrogram of size (..., freq, time) r}r~z-Expected an input with {} mel bins. Found: {}N)r) sizeviewrzrqrWrXr)relulinalglstsqrrsolution)r/rshaperqtimefreq_rYs r1r8zInverseMelScale.forwards ,,r59eBi8Ry%)'',,.a ;;& LSSTXT_T_aghi i::ell001B1B2r1J41PRYbfbmbm0nwwx==stTl!:;r2)rrrNNrrrrEs@r1rrs8M !%"''' '  '  'sm''' '6v&r2rc%eZdZdZgdZddddddddej d d dd d ddd fdededeedeede dee dedede de fde de dee de dedee deeded df$fd! Zd"e d e fd#ZxZS)$MelSpectrograma Create MelSpectrogram for a raw audio signal. .. devices:: CPU CUDA .. properties:: Autograd TorchScript This is a composition of :py:func:`torchaudio.transforms.Spectrogram` and :py:func:`torchaudio.transforms.MelScale`. Sources * https://gist.github.com/kastnerkyle/179d6e9a88202ab0a2fe * https://timsainb.github.io/spectrograms-mfccs-and-inversion-in-python.html * http://haythamfayek.com/2016/04/21/speech-processing-for-machine-learning.html Args: sample_rate (int, optional): Sample rate of audio signal. (Default: ``16000``) n_fft (int, optional): Size of FFT, creates ``n_fft // 2 + 1`` bins. (Default: ``400``) win_length (int or None, optional): Window size. (Default: ``n_fft``) hop_length (int or None, optional): Length of hop between STFT windows. (Default: ``win_length // 2``) f_min (float, optional): Minimum frequency. (Default: ``0.``) f_max (float or None, optional): Maximum frequency. (Default: ``None``) pad (int, optional): Two sided padding of signal. (Default: ``0``) n_mels (int, optional): Number of mel filterbanks. (Default: ``128``) window_fn (Callable[..., Tensor], optional): A function to create a window tensor that is applied/multiplied to each frame/window. (Default: ``torch.hann_window``) power (float, optional): Exponent for the magnitude spectrogram, (must be > 0) e.g., 1 for magnitude, 2 for power, etc. (Default: ``2``) normalized (bool, optional): Whether to normalize by magnitude after stft. (Default: ``False``) wkwargs (Dict[..., ...] or None, optional): Arguments for window function. (Default: ``None``) center (bool, optional): whether to pad :attr:`waveform` on both sides so that the :math:`t`-th frame is centered at time :math:`t \times \text{hop\_length}`. (Default: ``True``) pad_mode (string, optional): controls the padding method used when :attr:`center` is ``True``. (Default: ``"reflect"``) onesided: Deprecated and unused. norm (str or None, optional): If "slaney", divide the triangular mel weights by the width of the mel band (area normalization). (Default: ``None``) mel_scale (str, optional): Scale to use: ``htk`` or ``slaney``. (Default: ``htk``) Example >>> waveform, sample_rate = torchaudio.load("test.wav", normalize=True) >>> transform = transforms.MelSpectrogram(sample_rate) >>> mel_specgram = transform(waveform) # (channel, n_mels, time) See also: :py:func:`torchaudio.functional.melscale_fbanks` - The function used to generate the filter banks. )rrrrrrrqrsrrNrrrrFTrrrrrrrrsrtrrqr.rrrrr r!rvrwr#c tt| tjj d|t jd||_||_ ||n||_ ||n|jdz|_ ||_ | |_ | |_||_||_||_t%|j|j|j|j| |j|j| | |d |_t)|j|j|j"|j |jdzdz|||_y)Nz$torchaudio.transforms.MelSpectrogramz\Argument 'onesided' has been deprecated and has no influence on the behavior of this module.r%T) rrrrrrrrrr r!rV)r'rr(r)r*r+r-r.rrrrrrrrrqrtrsrr6rprw)r/rrrrrrsrtrrqrrrrrr r!rvrwr0s r1r(zMelSpectrogram.__init__,s!( nd,. $$%KL   MMn ' (2(>*E(2(>*DOOWXDX $   &****  " KK))4::tzz4::QR?UVCVX\^g r2r3cJ|j|}|j|}|S)z Args: waveform (Tensor): Tensor of audio of dimension (..., time). Returns: Tensor: Mel frequency spectrogram of size (..., ``n_mels``, time). )r6rw)r/r3rYrs r1r8zMelSpectrogram.forwardcs(##H-~~h/ r2)r9r:r;r<r=r)r>r?rr@rrrArCrBr(r8rDrEs@r1rrs8/`cM!$($(!%+0+<+< "&!#'"%5 5 5 SM 5 SM 5  5 5 5 5 CK(5 5 5 $5 5 5 4.!5 "sm#5 $%5 & '5 n  6 r2rcleZdZdZgdZ ddededededed ee d dffd Z d e d e fd Z xZ S)MFCCaCreate the Mel-frequency cepstrum coefficients from an audio signal. .. devices:: CPU CUDA .. properties:: Autograd TorchScript By default, this calculates the MFCC on the DB-scaled Mel spectrogram. This is not the textbook implementation, but is implemented here to give consistency with librosa. This output depends on the maximum value in the input spectrogram, and so may return different values for an audio clip split into snippets vs. a a full clip. Args: sample_rate (int, optional): Sample rate of audio signal. (Default: ``16000``) n_mfcc (int, optional): Number of mfc coefficients to retain. (Default: ``40``) dct_type (int, optional): type of DCT (discrete cosine transform) to use. (Default: ``2``) norm (str, optional): norm to use. (Default: ``"ortho"``) log_mels (bool, optional): whether to use log-mel spectrograms instead of db-scaled. (Default: ``False``) melkwargs (dict or None, optional): arguments for MelSpectrogram. (Default: ``None``) Example >>> waveform, sample_rate = torchaudio.load("test.wav", normalize=True) >>> transform = transforms.MFCC( >>> sample_rate=sample_rate, >>> n_mfcc=13, >>> melkwargs={"n_fft": 400, "hop_length": 160, "n_mels": 23, "center": False}, >>> ) >>> mfcc = transform(waveform) See also: :py:func:`torchaudio.functional.melscale_fbanks` - The function used to generate the filter banks. )rrn_mfccdct_typerdlog_melsNrrrrrvr melkwargsr#c8tt| dg}||vrtdj |||_||_||_||_d|_ td|j|_ |xsi}tdd|j i||_ |j |jjkDr tdtj|j |jj|j}|j!d|||_y) Nr%DCT type not supported: {}T@rrrz4Cannot select more MFCC coefficients than # mel binsdct_mat)r'rr(rWrXrrrrrvrdr^rmrrqr5 create_dctr,r) r/rrrrrvrrsupported_dct_typesrr0s r1r(z MFCC.__init__s dD"$ c . .9@@JK K&     ,WdkkBO ,W9I9IWYW ;;,,33 3ST T,,t{{D,?,?,F,F R Y0  r2r3c|j|}|jrd}tj||z}n|j |}tj |j dd|jj dd}|S)z Args: waveform (Tensor): Tensor of audio of dimension (..., time). Returns: Tensor: specgram_mel_db of size (..., ``n_mfcc``, time). ư>r}r~)rrr)logrmrrr)r/r3r log_offsetmfccs r1r8z MFCC.forwardsz**84 ==J 99\J%>?L// =L||L222r:DLLISSTVXZ[ r2)r(r%orthoFN)r9r:r;r<r=r?rBrArrCr(rr8rDrEs@r1rrps"FPM!$(!!! !  !  !D>! !:6r2rceZdZdZgdZ ddedededeeded ed ed e d ee d dffd Z de d e fdZ xZS)LFCCaCreate the linear-frequency cepstrum coefficients from an audio signal. .. devices:: CPU CUDA .. properties:: Autograd TorchScript By default, this calculates the LFCC on the DB-scaled linear filtered spectrogram. This is not the textbook implementation, but is implemented here to give consistency with librosa. This output depends on the maximum value in the input spectrogram, and so may return different values for an audio clip split into snippets vs. a a full clip. Args: sample_rate (int, optional): Sample rate of audio signal. (Default: ``16000``) n_filter (int, optional): Number of linear filters to apply. (Default: ``128``) n_lfcc (int, optional): Number of lfc coefficients to retain. (Default: ``40``) f_min (float, optional): Minimum frequency. (Default: ``0.``) f_max (float or None, optional): Maximum frequency. (Default: ``None``) dct_type (int, optional): type of DCT (discrete cosine transform) to use. (Default: ``2``) norm (str, optional): norm to use. (Default: ``"ortho"``) log_lf (bool, optional): whether to use log-lf spectrograms instead of db-scaled. (Default: ``False``) speckwargs (dict or None, optional): arguments for Spectrogram. (Default: ``None``) Example >>> waveform, sample_rate = torchaudio.load("test.wav", normalize=True) >>> transform = transforms.LFCC( >>> sample_rate=sample_rate, >>> n_lfcc=13, >>> speckwargs={"n_fft": 400, "hop_length": 160, "center": False}, >>> ) >>> lfcc = transform(waveform) See also: :py:func:`torchaudio.functional.linear_fbanks` - The function used to generate the filter banks. )rrn_filtern_lfccrrdlog_lfNrrrrsrtrrrvr speckwargsr#c 2tt| dg} || vrtdj |||_||_||n t|dz|_||_ ||_ ||_ ||_ d|_ td|j|_| xsi} t!d i| |_|j|j j"kDr tdt%j&|j j"dzdz|j |j|j|j } |j)d| t%j*|j|j|j} |j)d | ||_y) Nr%rrrz4Cannot select more LFCC coefficients than # fft binsrV)n_freqsrsrtrrr filter_matrr)r'rr(rWrXrrrsr@rtrrrrvrdr^rmrrr5 linear_fbanksr,rr)r/rrrrsrtrrrvrrrrrr0s r1r(z LFCC.__init__sa dD"$ c . .9@@JK K& #/UU;!;K5L        ,WdkkB%2 &44 ;;))// /ST T__$$**a/!3****]]((   \:6,,t{{DMM499E Y0 r2r3c|j|}tj|jdd|jjdd}|j rd}tj ||z}n|j|}tj|jdd|jjdd}|S)z Args: waveform (Tensor): Tensor of audio of dimension (..., time). Returns: Tensor: Linear Frequency Cepstral Coefficients of size (..., ``n_lfcc``, time). r}r~r) rr)rrrrrrmr)r/r3rYrlfccs r1r8z LFCC.forwards##H-<< 2 22r :DOOLVVWY[]^ ;;JyyJ!67H++H5H||H..r26 EOOPRTVW r2) rrrNrr%rFN)r9r:r;r<r=r?r@rrBrArCr(rr8rDrEs@r1rrs%LZM!!%%)+++ +  +  ++++TN+ +Z6r2rcDeZdZdZdgZddeddffd ZdedefdZxZ S) MuLawEncodingaEncode signal based on mu-law companding. .. devices:: CPU CUDA .. properties:: TorchScript For more info see the `Wikipedia Entry `_ This algorithm assumes the signal has been scaled to between -1 and 1 and returns a signal encoded with values from 0 to quantization_channels - 1 Args: quantization_channels (int, optional): Number of channels. (Default: ``256``) Example >>> waveform, sample_rate = torchaudio.load("test.wav", normalize=True) >>> transform = torchaudio.transforms.MuLawEncoding(quantization_channels=512) >>> mulawtrans = transform(waveform) quantization_channelsr#Nc8tt| ||_yrM)r'rr(rr/rr0s r1r(zMuLawEncoding.__init__M mT+-%:"r2rkcBtj||jS)z Args: x (Tensor): A signal to be encoded. Returns: Tensor: An encoded signal. )r5mu_law_encodingrrns r1r8zMuLawEncoding.forwardQs  D$>$>??r2 r9r:r;r<r=r?r(rr8rDrEs@r1rr5s;*--M;c;D;@@F@r2rcDeZdZdZdgZddeddffd ZdedefdZxZ S) MuLawDecodingaDecode mu-law encoded signal. .. devices:: CPU CUDA .. properties:: TorchScript For more info see the `Wikipedia Entry `_ This expects an input with values between 0 and ``quantization_channels - 1`` and returns a signal scaled between -1 and 1. Args: quantization_channels (int, optional): Number of channels. (Default: ``256``) Example >>> waveform, sample_rate = torchaudio.load("test.wav", normalize=True) >>> transform = torchaudio.transforms.MuLawDecoding(quantization_channels=512) >>> mulawtrans = transform(waveform) rr#Nc8tt| ||_yrM)r'rr(rrs r1r(zMuLawDecoding.__init__srr2x_mucBtj||jS)z Args: x_mu (Tensor): A mu-law encoded signal which needs to be decoded. Returns: Tensor: The signal decoded. )r5mu_law_decodingr)r/rs r1r8zMuLawDecoding.forwardws  t'A'ABBr2rrrEs@r1rr\s;(--M;c;D;CFCvCr2rceZdZdZ ddddededededed eed eejd dffd Z d e d e fdZ xZ S)ResampleaResample a signal from one frequency to another. A resampling method can be given. .. devices:: CPU CUDA .. properties:: Autograd TorchScript Note: If resampling on waveforms of higher precision than float32, there may be a small loss of precision because the kernel is cached once as float32. If high precision resampling is important for your application, the functional form will retain higher precision, but run slower because it does not cache the kernel. Alternatively, you could rewrite a transform that caches a higher precision kernel. Args: orig_freq (int, optional): The original frequency of the signal. (Default: ``16000``) new_freq (int, optional): The desired frequency. (Default: ``16000``) resampling_method (str, optional): The resampling method to use. Options: [``sinc_interp_hann``, ``sinc_interp_kaiser``] (Default: ``"sinc_interp_hann"``) lowpass_filter_width (int, optional): Controls the sharpness of the filter, more == sharper but less efficient. (Default: ``6``) rolloff (float, optional): The roll-off frequency of the filter, as a fraction of the Nyquist. Lower values reduce anti-aliasing, but also reduce some of the highest frequencies. (Default: ``0.99``) beta (float or None, optional): The shape parameter used for kaiser window. dtype (torch.device, optional): Determnines the precision that resampling kernel is pre-computed and cached. If not provided, kernel is computed with ``torch.float64`` then cached as ``torch.float32``. If you need higher precision, provide ``torch.float64``, and the pre-computed kernel is computed and cached as ``torch.float64``. If you use resample with lower precision, then instead of providing this providing this argument, please use ``Resample.to(dtype)``, so that the kernel generation is still carried out on ``torch.float64``. Example >>> waveform, sample_rate = torchaudio.load("test.wav", normalize=True) >>> transform = transforms.Resample(sample_rate, sample_rate/10) >>> waveform = transform(waveform) Ndtype orig_freqnew_freqresampling_methodlowpass_filter_widthrolloffbetarr#c t |||_||_t j t |jt |j|_||_||_||_ ||_ |j|jk7rjt|j|j|j |j|j|j||\}|_ |jd|yy)Nrkernel)r'r(rrrhgcdr?rrrrrwidthr,) r/rrrrrrrrr0s r1r(zResample.__init__s "  88C/T]]1CD!2$8!  >>T]] *!: )) && " FDJ  6 2 +r2r3c|j|jk(r|St||j|j|j|j|j S)z Args: waveform (Tensor): Tensor of audio of dimension (..., time). Returns: Tensor: Output signal of dimension (..., time). )rrr rrrr7s r1r8zResample.forwardsK >>T]] *O*8T^^T]]TXT\T\^b^i^ikokukuvvr2)rrsinc_interp_hannrTN)r9r:r;r<r?rBr@rr)rr(rr8rDrEs@r1rrs"L!3$% $ 3(, 3 3 3 3 " 3  3uo 3 $ 3  3D w w6 wr2rcHeZdZdZdgZd dededdffd ZdedefdZ xZ S) ComputeDeltasaCompute delta coefficients of a tensor, usually a spectrogram. .. devices:: CPU CUDA .. properties:: Autograd TorchScript See `torchaudio.functional.compute_deltas` for more details. Args: win_length (int, optional): The window length used for computing delta. (Default: ``5``) mode (str, optional): Mode parameter passed to padding. (Default: ``"replicate"``) rmoder#NcFtt| ||_||_yrM)r'rr(rr)r/rrr0s r1r(zComputeDeltas.__init__s mT+-$ r2rYcZtj||j|jS)z Args: specgram (Tensor): Tensor of audio of dimension (..., freq, time). Returns: Tensor: Tensor of deltas of dimension (..., freq, time). )rr)r5compute_deltasrrr\s r1r8zComputeDeltas.forwards!T__499UUr2) replicate) r9r:r;r<r=r?rBr(rr8rDrEs@r1rrsA "NM3# VV6Vr2rc deZdZdZdgZd deededeeddffd Zd de d eede fd Z xZ S) TimeStretchaStretch stft in time without modifying pitch for a given rate. .. devices:: CPU CUDA .. properties:: Autograd TorchScript Proposed in *SpecAugment* :cite:`specaugment`. Args: hop_length (int or None, optional): Length of hop between STFT windows. (Default: ``n_fft // 2``, where ``n_fft == (n_freq - 1) * 2``) n_freq (int, optional): number of filter banks from stft. (Default: ``201``) fixed_rate (float or None, optional): rate to speed up or slow down by. If None is provided, rate must be passed to the forward method. (Default: ``None``) .. note:: The expected input is raw, complex-valued spectrogram. Example >>> spectrogram = torchaudio.transforms.Spectrogram(power=None) >>> stretch = torchaudio.transforms.TimeStretch() >>> >>> original = spectrogram(waveform) >>> stretched_1_2 = stretch(original, 1.2) >>> stretched_0_9 = stretch(original, 0.9) .. image:: https://download.pytorch.org/torchaudio/doc-assets/specaugment_time_stretch.png :width: 600 :alt: The visualization of stretched spectrograms. fixed_rateNrn_freqr#ctt| ||_|dz dz}||n|dz}|j dt j dtj|z|dy)NrVr% phase_advancer).N) r'rr(rr,r)linspacerhpi)r/rrrrr0s r1r(zTimeStretch.__init__sb k4)+$!q #-#9Zuz  _ennQ*@TV\.]^g.hir2complex_specgramsoverriding_ratectj|stjdd|$|j t d|j}n|}t j|||jS)a2 Args: complex_specgrams (Tensor): A tensor of dimension `(..., freq, num_frame)` with complex dtype. overriding_rate (float or None, optional): speed up to apply to this batch. If no rate is passed, use ``self.fixed_rate``. (Default: ``None``) Returns: Tensor: Stretched spectrogram. The resulting tensor is of the corresponding complex dtype as the input spectrogram, and the number of frames is changed to ``ceil(num_frame / rate)``. zeThe input to TimeStretch must be complex type. Providing non-complex tensor produces invalid results.) stacklevelzLIf no fixed_rate is specified, must pass a valid rate to the forward method.) r) is_complexr-r.rrWr5 phase_vocoderr)r/rrrates r1r8zTimeStretch.forward sn 12 MMI   "& !opp??D"D0$8J8JKKr2)NrNrM) r9r:r;r<r=rr?r@r(rr8rDrEs@r1rrsf>"NMj8C=jjX`afXgjswjLL(5/L]cLr2rc eZdZdZddedededdffd Zdedefd Zd ed e jdefd Z d ed e jdefd Z xZ S)FadeaAdd a fade in and/or fade out to an waveform. .. devices:: CPU CUDA .. properties:: Autograd TorchScript Args: fade_in_len (int, optional): Length of fade-in (time frames). (Default: ``0``) fade_out_len (int, optional): Length of fade-out (time frames). (Default: ``0``) fade_shape (str, optional): Shape of fade. Must be one of: "quarter_sine", ``"half_sine"``, ``"linear"``, ``"logarithmic"``, ``"exponential"``. (Default: ``"linear"``) Example >>> waveform, sample_rate = torchaudio.load("test.wav", normalize=True) >>> transform = transforms.Fade(fade_in_len=sample_rate, fade_out_len=2 * sample_rate, fade_shape="linear") >>> faded_waveform = transform(waveform) fade_in_len fade_out_len fade_shaper#NcTtt| ||_||_||_yrM)r'rr(rrr)r/rrrr0s r1r(z Fade.__init__Qs' dD"$&($r2r3c|jd}|j}|j|||j||z|zS) Args: waveform (Tensor): Tensor of audio of dimension `(..., time)`. Returns: Tensor: Tensor of audio of dimension `(..., time)`. r})rdevice_fade_in _fade_out)r/r3waveform_lengthrs r1r8z Fade.forwardWsE#--/"-}}_f5X^8__bjjjr2rrctjdd|j|}tj||jz |}|jdk(r|}|jdk(rtj d|dz |z}|jdk(rtj d|zdz}|jd k(r)tj|tjzdz }|jd k(r@tj|tjztjdz z dz d z}tj||fjddS) NrrVrlinear exponentialr% logarithmic皙? quarter_sine half_sine?) r)rronesrpowrisinrhrcatclamp_r/rrfaders r1rz Fade._fade_incs~~aD$4$4VDzz/D,<,<DDyy$&--a33r2ctjdd|j|}tj||jz |}|jdk(r| dz}|jdk(rtj d| d|z z}|jdk(rtj d|z dz}|jd k(r=tj|tjzdz tjdz z}|jd k(r@tj|tjztjdz zdz d z}tj||fjddS) NrrVrr r r%r g?r rr) r)rrrrrrirrhrrrrs r1rzFade._fade_outxs%~~aD$5$5fEzz/D,=,==fM ??h &519D ??m +99Q&!d(3D ??m +;;sTz*Q.D ??n ,99TDGG^a/$''A+=>D ??k )99TDGG^dggk9:Q>DDyy$&--a33r2)rrr )r9r:r;r<r?rBr(rr8r)rrrrDrEs@r1rr=s}&%C%3%PS%cg% k k6 k44U\\4f4*44ell4v4r2rc XeZdZdZgdZd dededededdf fd Zdd e d ede fd Z xZ S) _AxisMaskinga/Apply masking to a spectrogram. Args: mask_param (int): Maximum possible length of the mask. axis (int): What dimension the mask is applied on (assuming the tensor is 3D). For frequency masking, axis = 1. For time masking, axis = 2. iid_masks (bool): Applies iid masks to each of the examples in the batch dimension. This option is applicable only when the dimension of the input tensor is >= 3. p (float, optional): maximum proportion of columns that can be masked. (Default: 1.0) ) mask_paramaxis iid_masksprrrrr#Ncbtt| ||_||_||_||_yrM)r'rr(rrrr)r/rrrrr0s r1r(z_AxisMasking.__init__s, lD*,$ "r2rY mask_valuecJ|jrLtj||j||j|j zdz |j Stj||j||j|j zdz |j S)a Args: specgram (Tensor): Tensor of dimension `(..., freq, time)`. mask_value (float): Value to assign to the masked columns. Returns: Tensor: Masked spectrogram of dimensions `(..., freq, time)`. r)rr5mask_along_axis_iidrrdimrmask_along_axis)r/rYrs r1r8z_AxisMasking.forwards >>(($//:tyy8<<>7QTU7UY]Y_Y_ $$Xt DIIX`XdXdXfLfijLjnrntntu ur2)rg)r r9r:r;r<r=r?rAr@r(rr8rDrEs@r1rrsV =M3cduW[vvEvFvr2rc2eZdZdZddededdffd ZxZS)FrequencyMaskingaHApply masking to a spectrogram in the frequency domain. .. devices:: CPU CUDA .. properties:: Autograd TorchScript Proposed in *SpecAugment* :cite:`specaugment`. Args: freq_mask_param (int): maximum possible length of the mask. Indices uniformly sampled from [0, freq_mask_param). iid_masks (bool, optional): whether to apply different masks to each example/channel in the batch. (Default: ``False``) This option is applicable only when the input tensor >= 3D. Example >>> spectrogram = torchaudio.transforms.Spectrogram() >>> masking = torchaudio.transforms.FrequencyMasking(freq_mask_param=80) >>> >>> original = spectrogram(waveform) >>> masked = masking(original) .. image:: https://download.pytorch.org/torchaudio/doc-assets/specaugment_freq_masking1.png :alt: The original spectrogram .. image:: https://download.pytorch.org/torchaudio/doc-assets/specaugment_freq_masking2.png :alt: The spectrogram masked along frequency axis freq_mask_paramrr#Nc0tt| |d|y)NrV)r'r(r()r/r)rr0s r1r(zFrequencyMasking.__init__s .9Mr2)F)r9r:r;r<r?rAr(rDrEs@r1r(r(s,:NNNNNr2r(c 6eZdZdZddedededdffd ZxZS) TimeMaskingaApply masking to a spectrogram in the time domain. .. devices:: CPU CUDA .. properties:: Autograd TorchScript Proposed in *SpecAugment* :cite:`specaugment`. Args: time_mask_param (int): maximum possible length of the mask. Indices uniformly sampled from [0, time_mask_param). iid_masks (bool, optional): whether to apply different masks to each example/channel in the batch. (Default: ``False``) This option is applicable only when the input tensor >= 3D. p (float, optional): maximum proportion of time steps that can be masked. Must be within range [0.0, 1.0]. (Default: 1.0) Example >>> spectrogram = torchaudio.transforms.Spectrogram() >>> masking = torchaudio.transforms.TimeMasking(time_mask_param=80) >>> >>> original = spectrogram(waveform) >>> masked = masking(original) .. image:: https://download.pytorch.org/torchaudio/doc-assets/specaugment_time_masking1.png :alt: The original spectrogram .. image:: https://download.pytorch.org/torchaudio/doc-assets/specaugment_time_masking2.png :alt: The spectrogram masked along time axis time_mask_paramrrr#Ncld|cxkrdksntd|dtt||d||y)Nrrgz,The value of p must be between 0.0 and 1.0 (z given).r%r")rWr'r,r()r/r-rrr0s r1r(zTimeMasking.__init__s;a3KA3hWX X k4)/1i1)Mr2)Frg) r9r:r;r<r?rAr@r(rDrEs@r1r,r,s5>NNNNY]NNr2r,cdeZdZdZgdZ ddedededededed ed d ffd Zd e d e fdZ xZ S) SpecAugmentaApply time and frequency masking to a spectrogram. Args: n_time_masks (int): Number of time masks. If its value is zero, no time masking will be applied. time_mask_param (int): Maximum possible length of the time mask. n_freq_masks (int): Number of frequency masks. If its value is zero, no frequency masking will be applied. freq_mask_param (int): Maximum possible length of the frequency mask. iid_masks (bool, optional): Applies iid masks to each of the examples in the batch dimension. This option is applicable only when the input tensor is 4D. (Default: ``True``) p (float, optional): maximum proportion of time steps that can be masked. Must be within range [0.0, 1.0]. (Default: 1.0) zero_masking (bool, optional): If ``True``, use 0 as the mask value, else use mean of the input tensor. (Default: ``False``) ) n_time_masksr- n_freq_masksr)rr zero_maskingr1r-r2r)rrr3r#Nctt| ||_||_||_||_||_||_||_ yrM) r'r0r(r1r-r2r)rrr3) r/r1r-r2r)rrr3r0s r1r(zSpecAugment.__init__sH k4)+(.(."(r2rYc|jrd}n|j}|jdz }|dz }|jdkDr|jdurt |j D]0}t j||j|||j}2t |jD]0}t j||j|||j}2|St |j D]0}t j||j|||j}2t |jD]0}t j||j|||j}2|S)z Args: specgram (Tensor): Tensor of shape `(..., freq, time)`. Returns: Tensor: Masked spectrogram of shape `(..., freq, time)`. rrVr%Tr") r3meanr$rranger1r5r#r-rr2r)r%)r/rYrtime_dimfreq_dimrs r1r8zSpecAugment.forward*si   J!J<<>A%a< <<>A $..D"84,,- q004;O;OQ[]eimioiop q4,,- q004;O;OQ[]eimioiop q 4,,- m,,Xt7K7KZYaeiekekl m4,,- m,,Xt7K7KZYaeiekekl mr2)TrgFr&rEs@r1r0r0s M "))) )  )  ) )) )&6r2r0c:eZdZdZdgZdeffd ZdefdZxZ S)LoudnessaMeasure audio loudness according to the ITU-R BS.1770-4 recommendation. .. devices:: CPU CUDA .. properties:: TorchScript Args: sample_rate (int): Sample rate of audio signal. Example >>> waveform, sample_rate = torchaudio.load("test.wav", normalize=True) >>> transform = transforms.Loudness(sample_rate) >>> loudness = transform(waveform) Reference: - https://www.itu.int/rec/R-REC-BS.1770-4-201510-I/en rrc8tt| ||_yrM)r'r;r(rr)r/rrr0s r1r(zLoudness.__init__Zs h&(&r2wavefromcBtj||jS)z Args: waveform(torch.Tensor): audio waveform of dimension `(..., channels, time)` Returns: Tensor: loudness estimates (LKFS) )r5loudnessrr)r/r=s r1r8zLoudness.forward^szz(D$4$455r2rrEs@r1r;r;Fs)"#OM'C'66r2r;c>eZdZdZddedeffd ZdedefdZxZ S) VolaAdjust volume of waveform. .. devices:: CPU CUDA .. properties:: Autograd TorchScript Args: gain (float): Interpreted according to the given gain_type: If ``gain_type`` = ``amplitude``, ``gain`` is a positive amplitude ratio. If ``gain_type`` = ``power``, ``gain`` is a power (voltage squared). If ``gain_type`` = ``db``, ``gain`` is in decibels. gain_type (str, optional): Type of gain. One of: ``amplitude``, ``power``, ``db`` (Default: ``amplitude``) Example >>> waveform, sample_rate = torchaudio.load("test.wav", normalize=True) >>> transform = transforms.Vol(gain=0.5, gain_type="amplitude") >>> quieter_waveform = transform(waveform) gain gain_typecptt| ||_||_|dvr|dkr t dyy)N) amplituderrz9If gain_type = amplitude or power, gain must be positive.)r'rAr(rBrCrW)r/rBrCr0s r1r(z Vol.__init__}sA c4!# " . .4!8XY Y4< .r2r3r#cT|jdk(r||jz}|jdk(r tj||j}|jdk(r6tj|dtj|jz}t j |ddS)rrEdbr r}rV)rCrBr5rhrir)clampr7s r1r8z Vol.forwards >>[ ($))+H >>T !vvh 2H >>W $vvhTZZ -B(BCH{{8R++r2)rE) r9r:r;r<r@rBr(rr8rDrEs@r1rArAis1&ZUZsZ,,6,r2rAc LeZdZdZ d dededededdf fd Zd edefd ZxZ S) SlidingWindowCmna Apply sliding-window cepstral mean (and optionally variance) normalization per utterance. .. devices:: CPU CUDA .. properties:: Autograd TorchScript Args: cmn_window (int, optional): Window in frames for running average CMN computation (int, default = 600) min_cmn_window (int, optional): Minimum CMN window used at start of decoding (adds latency only at start). Only applicable if center == false, ignored if center==true (int, default = 100) center (bool, optional): If true, use a window centered on the current frame (to the extent possible, modulo end effects). If false, window is to the left. (bool, default = false) norm_vars (bool, optional): If true, normalize variance to one. (bool, default = false) Example >>> waveform, sample_rate = torchaudio.load("test.wav", normalize=True) >>> transform = transforms.SlidingWindowCmn(cmn_window=1000) >>> cmn_waveform = transform(waveform) cmn_windowmin_cmn_windowr norm_varsr#NcZt|||_||_||_||_yrM)r'r(rLrMrrN)r/rLrMrrNr0s r1r(zSlidingWindowCmn.__init__s- $, "r2rYctj||j|j|j|j }|S)z Args: specgram (Tensor): Tensor of spectrogram of dimension `(..., time, freq)`. Returns: Tensor: Tensor of spectrogram of dimension `(..., time, freq)`. )r5sliding_window_cmnrLrMrrN)r/rY cmn_specgrams r1r8zSlidingWindowCmn.forwards:++HdootGZGZ\`\g\gimiwiwx r2)iXdFF) r9r:r;r<r?rAr(rr8rDrEs@r1rKrKsO,in##58#HL#ae# #  6 r2rKc%eZdZdZ ddedededededed ed ed ed ed edeededededededdf$fd ZdedefdZ xZ S)VaduVoice Activity Detector. Similar to SoX implementation. .. devices:: CPU CUDA .. properties:: TorchScript Attempts to trim silence and quiet background sounds from the ends of recordings of speech. The algorithm currently uses a simple cepstral power measurement to detect voice, so may be fooled by other things, especially music. The effect can trim only from the front of the audio, so in order to trim from the back, the reverse effect must also be used. Args: sample_rate (int): Sample rate of audio signal. trigger_level (float, optional): The measurement level used to trigger activity detection. This may need to be changed depending on the noise level, signal level, and other characteristics of the input audio. (Default: 7.0) trigger_time (float, optional): The time constant (in seconds) used to help ignore short bursts of sound. (Default: 0.25) search_time (float, optional): The amount of audio (in seconds) to search for quieter/shorter bursts of audio to include prior to the detected trigger point. (Default: 1.0) allowed_gap (float, optional): The allowed gap (in seconds) between quiteter/shorter bursts of audio to include prior to the detected trigger point. (Default: 0.25) pre_trigger_time (float, optional): The amount of audio (in seconds) to preserve before the trigger point and any found quieter/shorter bursts. (Default: 0.0) boot_time (float, optional) The algorithm (internally) uses adaptive noise estimation/reduction in order to detect the start of the wanted audio. This option sets the time for the initial noise estimate. (Default: 0.35) noise_up_time (float, optional) Time constant used by the adaptive noise estimator for when the noise level is increasing. (Default: 0.1) noise_down_time (float, optional) Time constant used by the adaptive noise estimator for when the noise level is decreasing. (Default: 0.01) noise_reduction_amount (float, optional) Amount of noise reduction to use in the detection algorithm (e.g. 0, 0.5, ...). (Default: 1.35) measure_freq (float, optional) Frequency of the algorithm’s processing/measurements. (Default: 20.0) measure_duration: (float or None, optional) Measurement duration. (Default: Twice the measurement period; i.e. with overlap.) measure_smooth_time (float, optional) Time constant used to smooth spectral measurements. (Default: 0.4) hp_filter_freq (float, optional) "Brick-wall" frequency of high-pass filter applied at the input to the detector algorithm. (Default: 50.0) lp_filter_freq (float, optional) "Brick-wall" frequency of low-pass filter applied at the input to the detector algorithm. (Default: 6000.0) hp_lifter_freq (float, optional) "Brick-wall" frequency of high-pass lifter used in the detector algorithm. (Default: 150.0) lp_lifter_freq (float, optional) "Brick-wall" frequency of low-pass lifter used in the detector algorithm. (Default: 2000.0) Example >>> waveform, sample_rate = torchaudio.load("test.wav", normalize=True) >>> waveform_reversed, sample_rate = apply_effects_tensor(waveform, sample_rate, [["reverse"]]) >>> transform = transforms.Vad(sample_rate=sample_rate, trigger_level=7.5) >>> waveform_reversed_front_trim = transform(waveform_reversed) >>> waveform_end_trim, sample_rate = apply_effects_tensor( >>> waveform_reversed_front_trim, sample_rate, [["reverse"]] >>> ) Reference: - http://sox.sourceforge.net/sox.html Nrr trigger_level trigger_time search_time allowed_gappre_trigger_time boot_time noise_up_timenoise_down_timenoise_reduction_amount measure_freqmeasure_durationmeasure_smooth_timehp_filter_freqlp_filter_freqhp_lifter_freqlp_lifter_freqr#ct|||_||_||_||_||_||_||_||_ | |_ | |_ | |_ | |_ | |_||_||_||_||_yrM)r'r(rrrVrWrXrYrZr[r\r]r^r_r`rarbrcrdre)r/rrrVrWrXrYrZr[r\r]r^r_r`rarbrcrdrer0s r1r(z Vad.__init__s( &*(&& 0"*.&<#( 0#6 ,,,,r2r3ctjdid|d|jd|jd|jd|j d|j d|jd|jd |jd |jd |jd |jd |jd|jd|jd|j d|j"d|j$S)aW Args: waveform (Tensor): Tensor of audio of dimension `(channels, time)` or `(time)` Tensor of shape `(channels, time)` is treated as a multi-channel recording of the same event and the resulting output will be trimmed to the earliest voice activity in any channel. r3rrrVrWrXrYrZr[r\r]r^r_r`rarbrcrdrer)r5vadrrrVrWrXrYrZr[r\r]r^r_r`rarbrcrdrer7s r1r8z Vad.forward.s)uu  (( ,, **  ((  ((  "22 nn ,, !00 $(#>#> ** "22 !% 8 8  ..  ..! " ..# $ ..%  r2)g@?rgrirgffffff?r g{Gz?g?rfNg?gI@gp@gb@g@@) r9r:r;r<r?r@rr(rr8rDrEs@r1rUrUs ?H #" !"%"!%(,",0%( $ & % &%&-&-&- &-  &-  &- &-&-&-&-!&&-&-#5/&-#&-&- !&-"#&-$%&-& '&-P  6 r2rUceZdZdZgdZddddej dfdededeed eed ed e d e fd ee ddffd Z de de fdZ xZS)SpectralCentroidaCompute the spectral centroid for each channel along the time axis. .. devices:: CPU CUDA .. properties:: Autograd TorchScript The spectral centroid is defined as the weighted average of the frequency values, weighted by their magnitude. Args: sample_rate (int): Sample rate of audio signal. n_fft (int, optional): Size of FFT, creates ``n_fft // 2 + 1`` bins. (Default: ``400``) win_length (int or None, optional): Window size. (Default: ``n_fft``) hop_length (int or None, optional): Length of hop between STFT windows. (Default: ``win_length // 2``) pad (int, optional): Two sided padding of signal. (Default: ``0``) window_fn (Callable[..., Tensor], optional): A function to create a window tensor that is applied/multiplied to each frame/window. (Default: ``torch.hann_window``) wkwargs (dict or None, optional): Arguments for window function. (Default: ``None``) Example >>> waveform, sample_rate = torchaudio.load("test.wav", normalize=True) >>> transform = transforms.SpectralCentroid(sample_rate) >>> spectral_centroid = transform(waveform) # (channel, time) )rrrrrrrNrrrrrrrr.rr#c tt| ||_||_||n||_||n|j dz|_|||j n||j fi|}|jd|||_yrI) r'rkr(rrrrrr,r) r/rrrrrrrrr&r0s r1r(zSpectralCentroid.__init__gs .0& (2(>*E(2(>*DOOWXDX/64??+IdooDiahDi Xv.r2r3c tj||j|j|j|j |j |jS)z Args: waveform (Tensor): Tensor of audio of dimension `(..., time)`. Returns: Tensor: Spectral Centroid of size `(..., time)`. )r5spectral_centroidrrrr&rrrr7s r1r8zSpectralCentroid.forwardzsC"" d&&$++tzz4??\`\k\k  r2)r9r:r;r<r=r)r>r?rrrrCr(r8rDrEs@r1rkrkLs0PM $($(+0+<+<"&SM  SM   CK($ &    6  r2rkceZdZUdZgdZeed<eed<ddddejdfded ed ed ed e ed e ede de fde e ddffd ZdZde de fdZxZS) PitchShiftaShift the pitch of a waveform by ``n_steps`` steps. .. devices:: CPU CUDA .. properties:: TorchScript Args: waveform (Tensor): The input waveform of shape `(..., time)`. sample_rate (int): Sample rate of `waveform`. n_steps (int): The (fractional) steps to shift `waveform`. bins_per_octave (int, optional): The number of steps per octave (Default : ``12``). n_fft (int, optional): Size of FFT, creates ``n_fft // 2 + 1`` bins (Default: ``512``). win_length (int or None, optional): Window size. If None, then ``n_fft`` is used. (Default: ``None``). hop_length (int or None, optional): Length of hop between STFT windows. If None, then ``win_length // 4`` is used (Default: ``None``). window (Tensor or None, optional): Window tensor that is applied/multiplied to each frame/window. If None, then ``torch.hann_window(win_length)`` is used (Default: ``None``). Example >>> waveform, sample_rate = torchaudio.load("test.wav", normalize=True) >>> transform = transforms.PitchShift(sample_rate, 4) >>> waveform_shift = transform(waveform) # (channel, time) )rrn_stepsbins_per_octaverrrrr iNrrrqrrrrrr.rr#c t |||_||_||_||_||n||_||n|j dz|_|||j n||j fi|} |jd| dt| |z z} t|| z |_ tjt|jt||_ |j|k7rd|_tdd|_yy)Nrr&rr})rr)r'r(rqrrrrrrrr,r@r?rrhrrr r) r/rrrqrrrrrrrr&rr0s r1r(zPitchShift.__init__s  .& (2(>*E(2(>*DOOWXDX/64??+IdooDiahDi Xv.g89[4/088C/[1AB >>[ (DJ0DIDK )r2c|jr|j|jk7rtj5t |j|j|j |j|j\}|_ |jj|j|jj|dddyyy#1swYyxYw)N)rr)has_uninitialized_paramsrrrr)no_gradrrrrrr materializercopy_)r/inputrs r1initialize_parametersz PitchShift.initialize_parameterss  ( ( *~~!1!11]]_ .)B((#kk$|| *&FDJKK++FLL9KK%%f- . .2 + . .s B CCr3c |j}t||j|j|j|j |j |j}|j|jk7rCt||j|j|j|j|j}n|}t||S)z Args: waveform (Tensor): Tensor of audio of dimension `(..., time)`. Returns: Tensor: The pitch-shifted audio of shape `(..., time)`. )rrrqrrrrrr&rrrr rrrr)r/r3rwaveform_stretchwaveform_shifts r1r8zPitchShift.forwards ,  LL  JJ OO OO KK  >>T-- -8     N.N"    r2)r9r:r;r<r=r __annotations__r?r)r>rrrrCr(r{r8rDrEs@r1rprps.gM "" J "$($(+0+<+<"&JJJ J  J SM JSMJCK(J$J J8 .# # 6# r2rpc VeZdZdZ d dedededeffd Zde de d e d e fd Z xZ S) RNNTLossaCompute the RNN Transducer loss from *Sequence Transduction with Recurrent Neural Networks* :cite:`graves2012sequence`. .. devices:: CPU CUDA .. properties:: Autograd TorchScript The RNN Transducer loss extends the CTC loss by defining a distribution over output sequences of all lengths, and by jointly modelling both input-output and output-output dependencies. Args: blank (int, optional): blank label (Default: ``-1``) clamp (float, optional): clamp for gradients (Default: ``-1``) reduction (string, optional): Specifies the reduction to apply to the output: ``"none"`` | ``"mean"`` | ``"sum"``. (Default: ``"mean"``) fused_log_softmax (bool): set to False if calling log_softmax outside of loss (Default: ``True``) Example >>> # Hypothetical values >>> logits = torch.tensor([[[[0.1, 0.6, 0.1, 0.1, 0.1], >>> [0.1, 0.1, 0.6, 0.1, 0.1], >>> [0.1, 0.1, 0.2, 0.8, 0.1]], >>> [[0.1, 0.6, 0.1, 0.1, 0.1], >>> [0.1, 0.1, 0.2, 0.1, 0.1], >>> [0.7, 0.1, 0.2, 0.1, 0.1]]]], >>> dtype=torch.float32, >>> requires_grad=True) >>> targets = torch.tensor([[1, 2]], dtype=torch.int) >>> logit_lengths = torch.tensor([2], dtype=torch.int) >>> target_lengths = torch.tensor([2], dtype=torch.int) >>> transform = transforms.RNNTLoss(blank=0) >>> loss = transform(logits, targets, logit_lengths, target_lengths) >>> loss.backward() blankrI reductionfused_log_softmaxcZt|||_||_||_||_yrM)r'r(rrIrr)r/rrIrrr0s r1r(zRNNTLoss.__init__s-   "!2r2logitstargets logit_lengthstarget_lengthsc tj|||||j|j|j|j S)a Args: logits (Tensor): Tensor of dimension `(batch, max seq length, max target length + 1, class)` containing output from joiner targets (Tensor): Tensor of dimension `(batch, max target length)` containing targets with zero padded logit_lengths (Tensor): Tensor of dimension `(batch)` containing lengths of each sequence from encoder target_lengths (Tensor): Tensor of dimension `(batch)` containing lengths of targets for each sequence Returns: Tensor: Loss with the reduction option applied. If ``reduction`` is ``"none"``, then size (batch), otherwise scalar. )r5 rnnt_lossrrIrr)r/rrrrs r1r8zRNNTLoss.forward's?${{     JJ JJ NN  " "  r2)r}gr6T) r9r:r;r<r?r@rBrAr(rr8rDrEs@r1rrsm"L"& 3 3 3 3  3       r2rc~eZdZdZd deddffd ZdejdejdejfdZxZ S) Convolvea Convolves inputs along their last dimension using the direct method. Note that, in contrast to :class:`torch.nn.Conv1d`, which actually applies the valid cross-correlation operator, this module applies the true `convolution`_ operator. .. devices:: CPU CUDA .. properties:: Autograd TorchScript Args: mode (str, optional): Must be one of ("full", "valid", "same"). * "full": Returns the full convolution result, with shape `(..., N + M - 1)`, where `N` and `M` are the trailing dimensions of the two inputs. (Default) * "valid": Returns the segment of the full convolution result corresponding to where the two inputs overlap completely, with shape `(..., max(N, M) - min(N, M) + 1)`. * "same": Returns the center segment of the full convolution result, with shape `(..., N)`. .. _convolution: https://en.wikipedia.org/wiki/Convolution rr#NcFt|t| ||_yrMr r'r(rr/rr0s r1r(zConvolve.__init__\T"  r2rkycFtj|||jSa Args: x (torch.Tensor): First convolution operand, with shape `(..., N)`. y (torch.Tensor): Second convolution operand, with shape `(..., M)` (leading dimensions must be broadcast-able with those of ``x``). Returns: torch.Tensor: Result of convolving ``x`` and ``y``, with shape `(..., L)`, where the leading dimensions match those of ``x`` and `L` is dictated by ``mode``. )r)r5convolverr/rkrs r1r8zConvolve.forwardbszz!QTYY//r2full r9r:r;r<rBr(r)rr8rDrEs@r1rrEsA,Sd 0 0%,, 05<< 0r2rc~eZdZdZd deddffd ZdejdejdejfdZxZ S) FFTConvolvea| Convolves inputs along their last dimension using FFT. For inputs with large last dimensions, this module is generally much faster than :class:`Convolve`. Note that, in contrast to :class:`torch.nn.Conv1d`, which actually applies the valid cross-correlation operator, this module applies the true `convolution`_ operator. Also note that this module can only output float tensors (int tensor inputs will be cast to float). .. devices:: CPU CUDA .. properties:: Autograd TorchScript Args: mode (str, optional): Must be one of ("full", "valid", "same"). * "full": Returns the full convolution result, with shape `(..., N + M - 1)`, where `N` and `M` are the trailing dimensions of the two inputs. (Default) * "valid": Returns the segment of the full convolution result corresponding to where the two inputs overlap completely, with shape `(..., max(N, M) - min(N, M) + 1)`. * "same": Returns the center segment of the full convolution result, with shape `(..., N)`. .. _convolution: https://en.wikipedia.org/wiki/Convolution rr#NcFt|t| ||_yrMrrs r1r(zFFTConvolve.__init__rr2rkrcFtj|||jSr)r5 fftconvolverrs r1r8zFFTConvolve.forwards}}Q 22r2rrrEs@r1rrpsA0Sd 3 3%,, 35<< 3r2rrspeedr#ctt||z}t|}tj||}||z||zfSrM)r?rhr)rrsource_sample_ratetarget_sample_raters r1_source_target_sample_ratersDUY./Y ((%'9 :C  $&8C&? ??r2ceZdZdZdfd ZddeejdeejeejffdZ xZ S)SpeedaxAdjusts waveform speed. .. devices:: CPU CUDA .. properties:: Autograd TorchScript Args: orig_freq (int): Original frequency of the signals in ``waveform``. factor (float): Factor by which to adjust speed of input. Values greater than 1.0 compress ``waveform`` in time, whereas values less than 1.0 stretch ``waveform`` in time. r#ct|||_||_t ||\|_|_t|j |j |_y)N)rr) r'r(rfactorrrrr resampler)r/rrr0s r1r(zSpeed.__init__sO " ;UV_ag;h8!8!D,C,CdNeNefr2lengthsc|d}nHtj||jz|jz j |j }|j ||fS) Args: waveform (torch.Tensor): Input signals, with shape `(..., time)`. lengths (torch.Tensor or None, optional): Valid lengths of signals in ``waveform``, with shape `(...)`. If ``None``, all elements in ``waveform`` are treated as valid. (Default: ``None``) Returns: (torch.Tensor, torch.Tensor or None): torch.Tensor Speed-adjusted waveform, with shape `(..., new_time).` torch.Tensor or None If ``lengths`` is not ``None``, valid lengths of signals in speed-adjusted waveform, with shape `(...)`; otherwise, ``None``. N)r)ceilrrtorr)r/r3r out_lengthss r1r8z Speed.forwardsX ?K**Wt/F/F%FI`I`%`addelerersK~~h'44r2)r#NrM) r9r:r;r<r(rr)rrr8rDrEs@r1rrsH g5%,,)?55QVQ]Q]_ghmhtht_uQuKv5r2rc eZdZdZdedeeddffd Z d dejde ejde eje ejffd Z xZ S) SpeedPerturbationaApplies the speed perturbation augmentation introduced in *Audio augmentation for speech recognition* :cite:`ko15_interspeech`. For a given input, the module samples a speed-up factor from ``factors`` uniformly at random and adjusts the speed of the input by that factor. .. devices:: CPU CUDA .. properties:: Autograd TorchScript Args: orig_freq (int): Original frequency of the signals in ``waveform``. factors (Sequence[float]): Factors by which to adjust speed of input. Values greater than 1.0 compress ``waveform`` in time, whereas values less than 1.0 stretch ``waveform`` in time. Example >>> speed_perturb = SpeedPerturbation(16000, [0.9, 1.1, 1.0, 1.0, 1.0]) >>> # waveform speed will be adjusted by factor 0.9 with 20% probability, >>> # 1.1 with 20% probability, and 1.0 (i.e. kept the same) with 60% probability. >>> speed_perturbed_waveform = speed_perturb(waveform, lengths) rfactorsr#Nc t|tjj |Dcgc]}t ||c}|_ycc}w)N)rr)r'r(r)nn ModuleListrspeeders)r/rrrr0s r1r(zSpeedPerturbation.__init__s; ++el,m[aUYv-V,mn ,msAr3rcttjt|jd}t |jD]\}}||k(s |||cSt d)rrzrhr-typingrrrrrr)rtorch.nn.modules.lazyr torch.nn.parameterr torchaudior r5 torchaudio.functional.functionalr r rrr__all__rModulerrGrOr^rprrrrrrrrrrrr(r,r0r;rArKrUrkrprrrr?r@rrrrrrrr2r1rs. == 15& b %((//b JS S lU U p.aEHHOO.abBuxxBJUehhooUptUXX__tnT588??Tnk588??k\$@EHHOO$@N#CEHHOO#CLQwuxxQwhVEHHOOV>EL%((//ELPN4588??N4b&v588??&vRN|ND#N,#NLD%((//DN 6uxx 6F-,%((//-,`(uxx(VE %((//E P9 uxx9 xj %((//j ZM uxxM `(0uxx(0V*3%((//*3Z@#@e@c3h@+5EHHOO+5\3[3[l:uxx:89%((//9888r2